@wenrwa/marketplace-cli 0.4.4 → 0.4.6

package/dist/bridge/folderPicker.d.ts

@@ -0,0 +1,34 @@
+/**
+ * lws-05 — OS-native folder picker (PRD D3b) behind POST /local/pick-folder.
+ * `pickerCommandFor` is a pure command table — easy to test per platform
+ * without spawning anything. `pickFolder` runs it with an injected runner
+ * (real implementation in commands/bridge.ts uses child_process.execFile);
+ * tests never shell out to osascript/PowerShell/zenity.
+ *
+ * "One picker at a time" (server-level, not spawn-level) is enforced by the
+ * HTTP route in server.ts, which gates concurrent /local/pick-folder calls —
+ * this module only knows how to run a single pick.
+ */
+export interface PickerCommand {
+    cmd: string;
+    args: string[];
+}
+export declare function pickerCommandFor(platform: string, opts: {
+    hasZenity: boolean;
+}): PickerCommand | null;
+export type PickFolderRunner = (cmd: string, args: string[]) => Promise<{
+    stdout: string;
+    code: number;
+}>;
+export type PickFolderResult = {
+    path: string;
+} | {
+    cancelled: true;
+} | {
+    unsupported: true;
+};
+export declare function pickFolder(opts: {
+    platform: string;
+    hasZenity: boolean;
+    run: PickFolderRunner;
+}): Promise<PickFolderResult>;

package/dist/bridge/folderPicker.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pickerCommandFor = pickerCommandFor;
+exports.pickFolder = pickFolder;
+function pickerCommandFor(platform, opts) {
+    if (platform === 'darwin') {
+        return { cmd: 'osascript', args: ['-e', 'POSIX path of (choose folder)'] };
+    }
+    if (platform === 'win32') {
+        const script = "Add-Type -AssemblyName System.Windows.Forms; " +
+            "$f = New-Object System.Windows.Forms.FolderBrowserDialog; " +
+            "if ($f.ShowDialog() -eq 'OK') { Write-Output $f.SelectedPath }";
+        return { cmd: 'powershell.exe', args: ['-NoProfile', '-Command', script] };
+    }
+    if (platform === 'linux' && opts.hasZenity) {
+        return { cmd: 'zenity', args: ['--file-selection', '--directory'] };
+    }
+    return null;
+}
+async function pickFolder(opts) {
+    const command = pickerCommandFor(opts.platform, { hasZenity: opts.hasZenity });
+    if (!command)
+        return { unsupported: true };
+    try {
+        const { stdout } = await opts.run(command.cmd, command.args);
+        const path = stdout.trim();
+        if (!path)
+            return { cancelled: true };
+        return { path };
+    }
+    catch {
+        // Non-zero exit (user hit Cancel) surfaces as a rejected promise from
+        // every platform's runner — treated as a plain cancel, not an error.
+        return { cancelled: true };
+    }
+}

package/dist/bridge/folderPickerRunner.d.ts

@@ -0,0 +1,3 @@
+import { PickFolderRunner } from './folderPicker';
+export declare const execFileRunner: PickFolderRunner;
+export declare function hasZenityInstalled(): Promise<boolean>;

package/dist/bridge/folderPickerRunner.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.execFileRunner = void 0;
+exports.hasZenityInstalled = hasZenityInstalled;
+/**
+ * lws-05 — real execFile-backed PickFolderRunner + zenity presence probe,
+ * wired into commands/bridge.ts's POST /local/pick-folder handler. Kept
+ * separate from folderPicker.ts (the pure command table + result logic) so
+ * that module never touches child_process directly and stays test-friendly.
+ */
+const child_process_1 = require("child_process");
+const execFileRunner = (cmd, args) => new Promise((resolve, reject) => {
+    (0, child_process_1.execFile)(cmd, args, (err, stdout) => {
+        if (err)
+            reject(err);
+        else
+            resolve({ stdout: stdout ?? '', code: 0 });
+    });
+});
+exports.execFileRunner = execFileRunner;
+function hasZenityInstalled() {
+    return new Promise((resolve) => {
+        (0, child_process_1.execFile)('which', ['zenity'], (err) => resolve(!err));
+    });
+}

package/dist/bridge/folderRegistry.d.ts

@@ -0,0 +1,19 @@
+export interface FolderEntry {
+    workspaceId: string;
+    name: string;
+    addedAt: string;
+}
+/** Keyed by absolute path. */
+export interface FolderRegistry {
+    v: 1;
+    entries: Record<string, FolderEntry>;
+}
+export declare function loadFolderRegistry(dir?: string): FolderRegistry;
+export declare function saveFolderRegistry(registry: FolderRegistry, dir?: string): void;
+export declare function upsertEntry(registry: FolderRegistry, absPath: string, entry: FolderEntry): FolderRegistry;
+export declare function removeEntryByPath(registry: FolderRegistry, absPath: string): FolderRegistry;
+export declare function removeEntryByWorkspaceId(registry: FolderRegistry, workspaceId: string): FolderRegistry;
+export declare function findEntryByPath(registry: FolderRegistry, absPath: string): FolderEntry | null;
+export declare function findEntryByWorkspaceId(registry: FolderRegistry, workspaceId: string): {
+    path: string;
+} & FolderEntry | null;

package/dist/bridge/folderRegistry.js

@@ -0,0 +1,100 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadFolderRegistry = loadFolderRegistry;
+exports.saveFolderRegistry = saveFolderRegistry;
+exports.upsertEntry = upsertEntry;
+exports.removeEntryByPath = removeEntryByPath;
+exports.removeEntryByWorkspaceId = removeEntryByWorkspaceId;
+exports.findEntryByPath = findEntryByPath;
+exports.findEntryByWorkspaceId = findEntryByWorkspaceId;
+/**
+ * lws-03 — folder→workspace registry. Backs `wen-market local add/list/
+ * remove` and the discovery advertisement (server.ts). Lives alongside the
+ * bridge's other dotfiles under ~/.wen-market/ rather than a second dotdir,
+ * matching config.ts's convention. File-backed so it survives daemon
+ * restart; pure ops below operate on an in-memory snapshot so add/remove
+ * logic is unit-testable without touching disk.
+ */
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const DEFAULT_DIR = path.join(os.homedir(), '.wen-market');
+const REGISTRY_NAME = 'local-workspaces.json';
+function ensureDir(dir) {
+    fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+}
+function loadFolderRegistry(dir = DEFAULT_DIR) {
+    try {
+        const parsed = JSON.parse(fs.readFileSync(path.join(dir, REGISTRY_NAME), 'utf-8'));
+        if (parsed && typeof parsed === 'object' && parsed.entries)
+            return parsed;
+        return { v: 1, entries: {} };
+    }
+    catch {
+        return { v: 1, entries: {} };
+    }
+}
+function saveFolderRegistry(registry, dir = DEFAULT_DIR) {
+    ensureDir(dir);
+    fs.writeFileSync(path.join(dir, REGISTRY_NAME), JSON.stringify(registry, null, 2) + '\n', { mode: 0o600 });
+}
+// ── Pure in-memory ops (no I/O — easy to unit test, easy to compose) ──────
+function upsertEntry(registry, absPath, entry) {
+    return { ...registry, entries: { ...registry.entries, [absPath]: entry } };
+}
+function removeEntryByPath(registry, absPath) {
+    const entries = { ...registry.entries };
+    delete entries[absPath];
+    return { ...registry, entries };
+}
+function removeEntryByWorkspaceId(registry, workspaceId) {
+    const entries = {};
+    for (const [p, e] of Object.entries(registry.entries)) {
+        if (e.workspaceId !== workspaceId)
+            entries[p] = e;
+    }
+    return { ...registry, entries };
+}
+function findEntryByPath(registry, absPath) {
+    return registry.entries[absPath] ?? null;
+}
+function findEntryByWorkspaceId(registry, workspaceId) {
+    for (const [p, e] of Object.entries(registry.entries)) {
+        if (e.workspaceId === workspaceId)
+            return { path: p, ...e };
+    }
+    return null;
+}

package/dist/bridge/framePacer.d.ts

@@ -0,0 +1,61 @@
+/**
+ * cbs-01 — keep-newest frame pacer (pure, no I/O).
+ *
+ * Backpressure policy for the cloud browser session's `browser-frame`
+ * stream (docs/prd/cloud-browser-session.md, "Backpressure" decision): the
+ * relay has no message-size limit and no built-in backpressure, so an
+ * unbounded queue in front of a slow consumer (bad wifi, a stalled pane) is
+ * how memory balloons. This pacer enforces "at most ONE undelivered frame
+ * per session, newest wins":
+ *
+ *   - The first pushed frame (nothing in flight) is delivered immediately.
+ *   - A frame pushed while one is already in flight (awaiting ack) is held
+ *     in a SINGLE queue slot, not appended to a list.
+ *   - A frame pushed while the queue slot is already occupied REPLACES it —
+ *     the replaced (older, now-stale) frame is counted as dropped and
+ *     discarded. The queue can never hold more than one frame, so memory
+ *     use is O(1) regardless of producer rate or consumer slowness.
+ *   - The queued frame (if any) is delivered exactly when the consumer
+ *     acks the in-flight one — delivery is entirely ack-gated, never
+ *     time-gated.
+ *
+ * This module owns NO timers and no cadence — target ~10fps (per the PRD)
+ * is the PRODUCER's concern (e.g. the CDP screencast ack loop calling
+ * push() at the capture rate). The pacer only decides deliver-now vs.
+ * queue-and-maybe-drop; it never sleeps, polls, or schedules anything.
+ *
+ * Input events (`browser-input`) do NOT go through this pacer — see the
+ * drop rule in browserFrames.ts. This module is frame-type-agnostic (`F`
+ * is generic) precisely so it can't accidentally be reused for input.
+ */
+export interface FramePacerStats {
+    /** Frames replaced in the queue slot before ever being delivered. */
+    droppedCount: number;
+    /** Frames actually handed to onDeliver. */
+    deliveredCount: number;
+}
+export interface FramePacerOptions<F> {
+    /**
+     * Called synchronously the moment the pacer decides to deliver a frame —
+     * either immediately inside push() (nothing in flight) or immediately
+     * inside ack() (a queued frame was waiting). Must not throw for frames
+     * the pacer already validated as deliverable; any error propagates to
+     * the caller of push()/ack() (the pacer does no error swallowing of its
+     * own — that's the producer/consumer's call).
+     */
+    onDeliver: (frame: F) => void;
+}
+export interface FramePacer<F> extends FramePacerStats {
+    /** Producer calls this once per captured frame. */
+    push(frame: F): void;
+    /** Consumer calls this once it has finished handling the last delivered
+     *  frame. If a frame is queued, it is delivered now (synchronously,
+     *  awaiting the NEXT ack) and the queue slot empties. A no-op if nothing
+     *  is queued, and a safe no-op after close(). */
+    ack(): void;
+    /** Ends the session: discards any queued frame (uncounted — it's not a
+     *  "replacement", the session is simply over) and makes every further
+     *  push()/ack() call a safe no-op. Idempotent. */
+    close(): void;
+}
+export declare function createFramePacer<F>(opts: FramePacerOptions<F>): FramePacer<F>;

package/dist/bridge/framePacer.js

@@ -0,0 +1,79 @@
+"use strict";
+/**
+ * cbs-01 — keep-newest frame pacer (pure, no I/O).
+ *
+ * Backpressure policy for the cloud browser session's `browser-frame`
+ * stream (docs/prd/cloud-browser-session.md, "Backpressure" decision): the
+ * relay has no message-size limit and no built-in backpressure, so an
+ * unbounded queue in front of a slow consumer (bad wifi, a stalled pane) is
+ * how memory balloons. This pacer enforces "at most ONE undelivered frame
+ * per session, newest wins":
+ *
+ *   - The first pushed frame (nothing in flight) is delivered immediately.
+ *   - A frame pushed while one is already in flight (awaiting ack) is held
+ *     in a SINGLE queue slot, not appended to a list.
+ *   - A frame pushed while the queue slot is already occupied REPLACES it —
+ *     the replaced (older, now-stale) frame is counted as dropped and
+ *     discarded. The queue can never hold more than one frame, so memory
+ *     use is O(1) regardless of producer rate or consumer slowness.
+ *   - The queued frame (if any) is delivered exactly when the consumer
+ *     acks the in-flight one — delivery is entirely ack-gated, never
+ *     time-gated.
+ *
+ * This module owns NO timers and no cadence — target ~10fps (per the PRD)
+ * is the PRODUCER's concern (e.g. the CDP screencast ack loop calling
+ * push() at the capture rate). The pacer only decides deliver-now vs.
+ * queue-and-maybe-drop; it never sleeps, polls, or schedules anything.
+ *
+ * Input events (`browser-input`) do NOT go through this pacer — see the
+ * drop rule in browserFrames.ts. This module is frame-type-agnostic (`F`
+ * is generic) precisely so it can't accidentally be reused for input.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createFramePacer = createFramePacer;
+function createFramePacer(opts) {
+    let awaitingAck = false;
+    let queued = null;
+    let closed = false;
+    let droppedCount = 0;
+    let deliveredCount = 0;
+    const deliver = (frame) => {
+        awaitingAck = true;
+        deliveredCount += 1;
+        opts.onDeliver(frame);
+    };
+    return {
+        get droppedCount() {
+            return droppedCount;
+        },
+        get deliveredCount() {
+            return deliveredCount;
+        },
+        push(frame) {
+            if (closed)
+                return;
+            if (!awaitingAck) {
+                deliver(frame);
+                return;
+            }
+            if (queued !== null)
+                droppedCount += 1; // replacing an already-queued frame
+            queued = { frame };
+        },
+        ack() {
+            if (closed)
+                return;
+            awaitingAck = false;
+            if (queued !== null) {
+                const next = queued.frame;
+                queued = null;
+                deliver(next);
+            }
+        },
+        close() {
+            closed = true;
+            queued = null;
+            awaitingAck = false;
+        },
+    };
+}

package/dist/bridge/localAdd.d.ts

@@ -0,0 +1,28 @@
+import { FolderRegistry } from './folderRegistry';
+export interface LocalAddCoreDeps {
+    loadRegistry: () => FolderRegistry;
+    saveRegistry: (registry: FolderRegistry) => void;
+    createWorkspace: (name: string) => Promise<{
+        workspace: {
+            id: string;
+            name: string;
+        };
+    }>;
+}
+export type LocalAddCoreResult = {
+    status: 'created';
+    workspace: {
+        id: string;
+        name: string;
+    };
+} | {
+    status: 'existing';
+    workspace: {
+        id: string;
+        name: string;
+    };
+} | {
+    status: 'error';
+    message: string;
+};
+export declare function addLocalWorkspaceCore(absPath: string, nameOverride: string | undefined, deps: LocalAddCoreDeps): Promise<LocalAddCoreResult>;

package/dist/bridge/localAdd.js

@@ -0,0 +1,67 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addLocalWorkspaceCore = addLocalWorkspaceCore;
+/**
+ * lws-05 — bridge-side idempotent add core, behind POST /local/add. Mirrors
+ * `wen-market local add`'s behavior (commands/local.ts) so the arena
+ * create-modal's Browse/typed-path attach mechanisms (PRD D3b/D3c) end at the
+ * exact same registered-workspace outcome as the CLI mechanism (D3a) —
+ * deps-injected so server.ts can wire it without this module knowing about
+ * fs, network, or the WorkspaceRecord shape server.ts already has.
+ */
+const path = __importStar(require("path"));
+const folderRegistry_1 = require("./folderRegistry");
+async function addLocalWorkspaceCore(absPath, nameOverride, deps) {
+    const registry = deps.loadRegistry();
+    const existing = (0, folderRegistry_1.findEntryByPath)(registry, absPath);
+    if (existing) {
+        return { status: 'existing', workspace: { id: existing.workspaceId, name: existing.name } };
+    }
+    const name = nameOverride || path.basename(absPath);
+    try {
+        const result = await deps.createWorkspace(name);
+        const updated = (0, folderRegistry_1.upsertEntry)(registry, absPath, {
+            workspaceId: result.workspace.id,
+            name: result.workspace.name,
+            addedAt: new Date().toISOString(),
+        });
+        deps.saveRegistry(updated);
+        return { status: 'created', workspace: result.workspace };
+    }
+    catch (err) {
+        return { status: 'error', message: err?.message || String(err) };
+    }
+}

package/dist/bridge/localPathValidation.d.ts

@@ -0,0 +1,20 @@
+export interface LocalPathDeps {
+    exists: (absPath: string) => boolean;
+    isDirectory: (absPath: string) => boolean;
+    /** Best-effort readability probe (e.g. fs.accessSync with R_OK). */
+    readable: (absPath: string) => boolean;
+    /** Counts files under the folder (implementation may cap/skip heavy dirs
+     *  like node_modules/.git — this is a quick echo, not the D5 tree scan). */
+    countFiles: (absPath: string) => number;
+    isGitRepo: (absPath: string) => boolean;
+}
+export type ValidatePathResult = {
+    ok: true;
+    name: string;
+    fileCount: number;
+    isGitRepo: boolean;
+} | {
+    ok: false;
+    error: 'not-exists' | 'not-dir' | 'unreadable';
+};
+export declare function validateLocalPath(absPath: string, deps: LocalPathDeps): Promise<ValidatePathResult>;

package/dist/bridge/localPathValidation.js

@@ -0,0 +1,58 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateLocalPath = validateLocalPath;
+/**
+ * lws-05 — POST /local/validate-path. Backs the create-modal's typed-path
+ * fallback (PRD D3c): echoes "my-app — 214 files, git repo detected" (or a
+ * typed error) before the user confirms. Pure logic, fs fully injected so
+ * the endpoint handler (server.ts) is unit-testable without real disk I/O —
+ * the real implementation (wired in commands/bridge.ts) uses node:fs/path.
+ */
+const path = __importStar(require("path"));
+async function validateLocalPath(absPath, deps) {
+    if (!deps.exists(absPath))
+        return { ok: false, error: 'not-exists' };
+    if (!deps.isDirectory(absPath))
+        return { ok: false, error: 'not-dir' };
+    if (!deps.readable(absPath))
+        return { ok: false, error: 'unreadable' };
+    return {
+        ok: true,
+        name: path.basename(absPath),
+        fileCount: deps.countFiles(absPath),
+        isGitRepo: deps.isGitRepo(absPath),
+    };
+}

package/dist/bridge/localPathValidationFs.d.ts

@@ -0,0 +1,2 @@
+import { LocalPathDeps } from './localPathValidation';
+export declare function realLocalPathDeps(): LocalPathDeps;

package/dist/bridge/localPathValidationFs.js

@@ -0,0 +1,98 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.realLocalPathDeps = realLocalPathDeps;
+/**
+ * lws-05 — real fs-backed LocalPathDeps for POST /local/validate-path
+ * (commands/bridge.ts wiring). File count is a quick echo for the
+ * create-modal ("my-app — 214 files, git repo detected"), NOT the D5 tree
+ * scan — it skips node_modules/.git and hard-caps to keep the endpoint fast
+ * on huge folders.
+ */
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const SKIP_DIRS = new Set(['node_modules', '.git']);
+const COUNT_CAP = 20000;
+function countFiles(root) {
+    let count = 0;
+    const stack = [root];
+    while (stack.length > 0 && count < COUNT_CAP) {
+        const dir = stack.pop();
+        let entries;
+        try {
+            entries = fs.readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const entry of entries) {
+            if (count >= COUNT_CAP)
+                break;
+            if (entry.isDirectory()) {
+                if (SKIP_DIRS.has(entry.name))
+                    continue;
+                stack.push(path.join(dir, entry.name));
+            }
+            else {
+                count++;
+            }
+        }
+    }
+    return count;
+}
+function realLocalPathDeps() {
+    return {
+        exists: (p) => fs.existsSync(p),
+        isDirectory: (p) => {
+            try {
+                return fs.statSync(p).isDirectory();
+            }
+            catch {
+                return false;
+            }
+        },
+        readable: (p) => {
+            try {
+                fs.accessSync(p, fs.constants.R_OK);
+                return true;
+            }
+            catch {
+                return false;
+            }
+        },
+        countFiles,
+        isGitRepo: (p) => fs.existsSync(path.join(p, '.git')),
+    };
+}