dsh-mobilecode 0.1.0

package/lib/setup.js

@@ -0,0 +1,243 @@
+/**
+ * dsh-mobilecode — setup services (settings store, plugin doctor, PaddleOCR installer).
+ *
+ * Shared user-level state lives under ~/.dsh/mobilecode/ (same place as the OCR
+ * venv), so it survives GUI restarts and is independent of the mounted copy.
+ */
+
+import { spawn } from "node:child_process"
+import { existsSync, mkdirSync, readFileSync, writeFileSync, appendFileSync } from "node:fs"
+import os from "node:os"
+import path from "node:path"
+import { fileURLToPath } from "node:url"
+import * as DeviceBuild from "./device-build.js"
+
+export const HOME = path.join(os.homedir(), ".dsh", "mobilecode")
+const SETTINGS_FILE = path.join(HOME, "settings.json")
+const OCR_LOG_FILE = path.join(HOME, "ocr-install.log")
+export const OCR_README = path.join(HOME, "OCR-INSTALL.md")
+
+export function ensureHome() {
+  if (!existsSync(HOME)) mkdirSync(HOME, { recursive: true })
+}
+
+// ── settings ──────────────────────────────────────────────────────────────────
+
+export function readSettings() {
+  ensureHome()
+  try {
+    return JSON.parse(readFileSync(SETTINGS_FILE, "utf8"))
+  } catch {
+    return {}
+  }
+}
+
+export function writeSettings(patch) {
+  ensureHome()
+  const next = { ...readSettings(), ...patch }
+  try {
+    writeFileSync(SETTINGS_FILE, JSON.stringify(next, null, 2) + "\n", "utf8")
+  } catch {
+    /* read-only home — settings degrade to in-memory */
+  }
+  return next
+}
+
+// ── OCR installer ──────────────────────────────────────────────────────────────
+
+const OCR_PACKAGES = ["setuptools", "wheel", "numpy<2", "paddleocr==3.7.0", "paddlepaddle==3.3.1"]
+const OCR_INSTALL_STATE = { state: "idle", log: [], done: false, failed: false } // in-memory + log file
+
+function ocrLog(line) {
+  OCR_INSTALL_STATE.log.push(line)
+  if (OCR_INSTALL_STATE.log.length > 200) OCR_INSTALL_STATE.log.splice(0, OCR_INSTALL_STATE.log.length - 200)
+  try { appendFileSync(OCR_LOG_FILE, line + "\n", "utf8") } catch { /* ignore */ }
+}
+
+/** True when the venv python exists AND imports paddleocr — the real "installed" test. */
+export async function ocrWorking() {
+  const python = DeviceBuild.ocrPython()
+  if (!python) return false
+  const probe = await DeviceBuild.capture(python, ["-c", "import paddleocr, paddle; print('ok')"]).catch(() => "")
+  return probe.includes("ok")
+}
+
+/** Current OCR state for the UI: installed / working / install progress / failure. */
+export async function ocrStatus() {
+  const python = DeviceBuild.ocrPython()
+  const working = await ocrWorking()
+  const state = OCR_INSTALL_STATE.state
+  const out = { installed: !!python, working, state: "idle", log: [] }
+  if (OCR_INSTALL_STATE.failed) out.state = "failed"
+  else if (state === "installing") out.state = "installing"
+  else if (working) out.state = "done"
+  out.log = OCR_INSTALL_STATE.log.slice(-60)
+  if (out.state === "failed" && out.log.length === 0) {
+    try {
+      const tail = readFileSync(OCR_LOG_FILE, "utf8").split("\n").slice(-60)
+      out.log = tail
+    } catch { /* no log file yet */ }
+  }
+  return out
+}
+
+/**
+ * Start a detached PaddleOCR install (venv + pip) that survives GUI restarts.
+ * Writes an install script to disk and spawns it via cmd.exe, so the chain
+ * keeps running even if dsh exits. The script appends to OCR_LOG_FILE so
+ * status can always be recovered by a later GUI.
+ */
+export function startOcrInstall() {
+  ensureHome()
+  if (OCR_INSTALL_STATE.state === "installing") return { started: false, message: "install already in progress" }
+  OCR_INSTALL_STATE.state = "installing"
+  OCR_INSTALL_STATE.done = false
+  OCR_INSTALL_STATE.failed = false
+  OCR_INSTALL_STATE.log = []
+
+  const venv = path.join(HOME, "ocr-venv")
+  const python = path.join(venv, "Scripts", "python.exe")
+  const scriptFile = path.join(HOME, "ocr-install.cmd")
+  const lines = [
+    "@echo off",
+    "setlocal",
+    `echo [dsh-mobilecode] OCR install started %date% %time% >> "${OCR_LOG_FILE}"`,
+    `echo venv: ${venv} >> "${OCR_LOG_FILE}"`,
+    `py -3.12 -m venv "${venv}" >> "${OCR_LOG_FILE}" 2>&1 || py -3 -m venv "${venv}" >> "${OCR_LOG_FILE}" 2>&1 || python -m venv "${venv}" >> "${OCR_LOG_FILE}" 2>&1`,
+    `"${python}" -m pip install --disable-pip-version-check ${OCR_PACKAGES.map((p) => `"${p}"`).join(" ")} >> "${OCR_LOG_FILE}" 2>&1`,
+    `echo INSTALL_EXIT=%ERRORLEVEL% >> "${OCR_LOG_FILE}"`,
+  ]
+  try {
+    writeFileSync(scriptFile, lines.join("\r\n"), "utf8")
+  } catch (error) {
+    OCR_INSTALL_STATE.state = "failed"
+    OCR_INSTALL_STATE.failed = true
+    return { started: false, message: `cannot write install script: ${error.message}` }
+  }
+
+  const child = spawn("cmd.exe", ["/c", scriptFile], {
+    detached: true,
+    stdio: "ignore",
+    windowsHide: true,
+  })
+  child.unref()
+
+  ocrLog(`install started (script ${scriptFile})`)
+  OCR_INSTALL_STATE.state = "installing"
+
+  // The detached child writes INSTALL_EXIT=<code> to the log; poll for it.
+  const poll = setInterval(async () => {
+    try {
+      const log = readFileSync(OCR_LOG_FILE, "utf8")
+      if (/INSTALL_EXIT=0/.test(log)) {
+        clearInterval(poll)
+        OCR_INSTALL_STATE.state = "done"
+        OCR_INSTALL_STATE.done = true
+        ocrLog("install completed")
+      } else if (/INSTALL_EXIT=[1-9]/.test(log)) {
+        clearInterval(poll)
+        OCR_INSTALL_STATE.state = "failed"
+        OCR_INSTALL_STATE.failed = true
+        ocrLog("install failed (see log above)")
+      }
+    } catch { /* log not written yet */ }
+  }, 2000)
+  poll.unref?.()
+
+  return { started: true, log: OCR_INSTALL_STATE.log.slice(-10) }
+}
+
+// ── plugin doctor ──────────────────────────────────────────────────────────────
+
+const SYSTEM_CHECK = (name, ok, detail, fix) => ({ name, ok, detail, ...(fix ? { fix } : {}) })
+
+/** Run every health check. Each entry: {id, name, ok, detail, fix?}. */
+export async function runDoctor() {
+  const checks = []
+
+  // 1. Runtime: node + npm/npx reachable.
+  const nodeOk = typeof process.version === "string"
+  checks.push(SYSTEM_CHECK("runtime", nodeOk, `node ${process.version ?? "?"} (dsh host)`))
+
+  // 2. Android SDK: adb + emulator binaries.
+  const adbPath = DeviceBuild.adb()
+  const sdkOk = !!adbPath && existsSync(adbPath)
+  checks.push(SYSTEM_CHECK("android-sdk", sdkOk, sdkOk ? `adb at ${adbPath}` : "Android SDK not found (adb missing). Install Android Studio or set ANDROID_HOME."))
+
+  // 3. Emulator binary.
+  const emulatorPath = DeviceBuild.emulatorBinary()
+  checks.push(SYSTEM_CHECK("emulator", !!emulatorPath, emulatorPath ? `emulator at ${emulatorPath}` : "Emulator binary not found under the Android SDK."))
+
+  // 4. AVDs configured.
+  const avds = await DeviceBuild.androidAvds().catch(() => [])
+  checks.push(SYSTEM_CHECK("avds", avds.length > 0, avds.length > 0 ? `AVDs: ${avds.join(", ")}` : "No AVDs configured. Create one in Android Studio (Device Manager)."))
+
+  // 5. Attached device (live runs need one).
+  const devices = await DeviceBuild.devices().catch(() => [])
+  const attached = devices.filter((d) => d.state === "device")
+  checks.push(SYSTEM_CHECK("device", attached.length > 0, attached.length > 0 ? `attached: ${attached.map((d) => d.serial).join(", ")}` : "No Android device attached. device_run auto-boots an AVD when one is configured."))
+
+  // 6. PaddleOCR (device_screen OCR) — the only auto-fixable check.
+  const python = DeviceBuild.ocrPython()
+  const working = await ocrWorking()
+  checks.push(SYSTEM_CHECK("paddleocr", working,
+    working ? `PaddleOCR ready at ${python}` : python ? "PaddleOCR venv exists but imports failed (broken install)." : "PaddleOCR not installed — device_screen OCR is disabled. Fix installs it automatically.",
+    "install"))
+
+  // 7. OCR script reachable (part of the package).
+  const scriptOk = existsSync(fileURLToPath(new URL("../scripts/ocr.py", import.meta.url)))
+  checks.push(SYSTEM_CHECK("ocr-script", scriptOk, scriptOk ? "ocr.py present in the plugin package" : "ocr.py missing — reinstall the plugin."))
+
+  return checks
+}
+
+/** Try to auto-fix one check by id. Returns {ok, message}. */
+export async function runFix(id) {
+  if (id === "paddleocr") {
+    const started = startOcrInstall()
+    if (!started.started) return { ok: false, message: started.message ?? "unknown" }
+    return { ok: true, message: "PaddleOCR install started in the background. Check OCR status in a minute." }
+  }
+  return { ok: false, message: `no automatic fix for "${id}"` }
+}
+
+// ── welcome / ai prompt ────────────────────────────────────────────────────────
+
+/** The straight-to-the-point prompt shown on first run; copy-paste into any AI. */
+export const WELCOME_PROMPT = [
+  "You have the dsh-mobilecode plugin, which controls the iOS Simulator / Android Emulator on this machine — the same as the device pane's Play button.",
+  "",
+  "Tools:",
+  "- device_detect <directory>: which platforms (ios/android) a project supports and what is attached. Use first when a project may be mobile.",
+  "- device_run {action: run|stop|status, platform: ios|android|all, directory}: build, install and launch the app (auto-boots the emulator; minutes).",
+  "- device_screen: screenshot PNG + UI hierarchy + local PaddleOCR text, each with ABSOLUTE pixel boxes (e.g. 1080x2400). See what is on screen.",
+  "- device_input {action: tap|swipe|text|key, x, y, ...}: act at absolute pixel coordinates — take the center of a device_screen box: x=(x1+x2)/2, y=(y1+y2)/2.",
+  "- device_log {buffer: main|crash|events|kernel, filter}: logcat + kernel dmesg. Use when a run fails or the app misbehaves.",
+  "- device_status: one snapshot of attached devices, AVDs, running builds, Metro and preview servers.",
+  "",
+  "Recommended loop: device_detect → device_run → device_screen → device_input → device_screen (verify the change).",
+  "When something breaks, device_log (crash buffer, or filter by the app package) tells you why.",
+  "Coordinates are deterministic physical pixels; always re-read the screen right before acting.",
+].join("\n")
+
+export const OCR_SETUP_README = [
+  "# PaddleOCR — dsh-mobilecode",
+  "",
+  "`device_screen` OCR is powered by a fully local PaddleOCR venv at:",
+  "",
+  "    " + path.join(HOME, "ocr-venv"),
+  "",
+  "Installed automatically via the Settings → Doctor / PaddleOCR page (one click), or manually:",
+  "",
+  "    py -3.12 -m venv " + path.join(HOME, "ocr-venv"),
+  "    " + path.join(HOME, "ocr-venv", "Scripts", "python.exe") + " -m pip install setuptools wheel \"numpy<2\" \"paddleocr==3.7.0\" \"paddlepaddle==3.3.1\"",
+  "",
+  "Paddle 3.x on Windows needs oneDNN disabled (ocr.py passes enable_mkldnn=False);",
+  "with that, 3.7.0 works and reads text better than the old 2.7.3 pin (PP-OCRv6 models).",
+  "Set DSH_MOBILECODE_OCR_PY to override the venv location.",
+].join("\n")
+
+export function writeOcrReadme() {
+  ensureHome()
+  try { writeFileSync(OCR_README, OCR_SETUP_README, "utf8") } catch { /* ignore */ }
+}

package/package.json

@@ -0,0 +1,68 @@
+{
+  "name": "dsh-mobilecode",
+  "description": "MobileCode for the dsh web GUI: detect iOS/Android projects, run serve-sim / serve-avd preview servers, and build-install-launch the app on the simulator or emulator from the session — plus agent tools (device_run, device_detect). Hot-pluggable — mounted via the profile bundle list + cordis.patch.yml, no dsh source changes.",
+  "version": "0.1.0",
+  "type": "module",
+  "packageManager": "pnpm@11.22.0",
+  "engines": {
+    "node": "^22.19.0 || >=24.0.0"
+  },
+  "main": "lib/index.js",
+  "exports": {
+    ".": {
+      "default": "./lib/index.js"
+    },
+    "./client": {
+      "default": "./lib/client.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    },
+    "client": {
+      "inject": [
+        "@deepseek-ai/dsh-client-runtime"
+      ],
+      "platform": "web"
+    }
+  },
+  "peerDependencies": {
+    "react": "^18.2.0",
+    "react-dom": "^18.2.0"
+  },
+  "files": [
+    "lib/**/*.js",
+    "scripts/**/*.py",
+    "cordis.patch.yml",
+    "README.md"
+  ],
+  "license": "MIT",
+  "author": "spix18 <spix18@users.noreply.github.com> (https://github.com/spix18)",
+  "keywords": [
+    "dsh",
+    "deepseek-harness",
+    "plugin",
+    "mobilecode",
+    "mobile",
+    "ios",
+    "android",
+    "emulator",
+    "simulator",
+    "device",
+    "preview",
+    "expo",
+    "react-native",
+    "ocr",
+    "paddleocr"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/spix18/dsh-mobilecode.git"
+  },
+  "homepage": "https://github.com/spix18/dsh-mobilecode#readme",
+  "bugs": {
+    "url": "https://github.com/spix18/dsh-mobilecode/issues"
+  }
+}

package/scripts/ocr.py

@@ -0,0 +1,111 @@
+#!/usr/bin/env python
+"""PaddleOCR one-shot over an image; prints JSON to stdout.
+
+Usage: python ocr.py <image.png> [lang]
+Output: {"items":[{"text":str,"confidence":float,"box":[x1,y1,x2,y2]}], "error":str?}
+
+Works with both PaddleOCR 2.x (ocr.ocr) and 3.x (ocr.predict) APIs.
+The process exits after one image so the host never keeps a model resident;
+PaddleOCR caches the model in ~/.paddleocr between runs.
+"""
+import json
+import os
+import sys
+
+# Paddle 3.x PIR executor hits a oneDNN conversion bug on Windows; the CPU backend
+# without mkldnn avoids it. Must be set before `import paddle`.
+os.environ.setdefault("FLAGS_use_mkldnn", "0")
+
+
+def main():
+    if len(sys.argv) < 2:
+        print(json.dumps({"error": "missing image path"}))
+        return 1
+    image = sys.argv[1]
+    lang = sys.argv[2] if len(sys.argv) > 2 else "ch"
+    try:
+        from paddleocr import PaddleOCR
+    except Exception as exc:  # noqa: BLE001
+        print(json.dumps({"error": f"paddleocr import failed: {exc}"}))
+        return 1
+
+    items = []
+    # enable_mkldnn=False: paddle 3.x on Windows crashes in the oneDNN PIR
+    # executor (ConvertPirAttribute2RuntimeAttribute); the flag is a no-op-safe
+    # on 2.x, so this single constructor keeps both stacks working (CPU only).
+    # use_doc_unwarping=False (3.x only): the UVDoc unwarping model runs by
+    # default and shifts coordinates on non-document images (phone screenshots
+    # came out ~80px off in Y); disabling it returns pixel-accurate boxes.
+    version3 = str(getattr(__import__("paddleocr"), "__version__", "")).startswith("3")
+    if version3:
+        ocr = PaddleOCR(lang=lang, enable_mkldnn=False, use_doc_unwarping=False)
+    else:
+        ocr = PaddleOCR(lang=lang, enable_mkldnn=False)
+    if hasattr(ocr, "predict"):
+        # PaddleOCR 3.x API.
+        try:
+            for result in ocr.predict(image):
+                # OCRResult is a dict subclass whose dict view carries the
+                # fields we need; its `.json` property has a different shape
+                # ({'res': ...}), so always read the dict view first.
+                data = result if isinstance(result, dict) else getattr(result, "json", result)
+                if not isinstance(data, dict):
+                    continue
+                texts = data.get("rec_texts") or []
+                scores = data.get("rec_scores") or []
+                # dt_polys = list of (4,2) corner-point arrays; rec_boxes is a
+                # flat [x1,y1,x2,y2] ndarray — never use `or` on an ndarray.
+                boxes = data.get("dt_polys")
+                if boxes is None or len(boxes) == 0:
+                    boxes = data.get("rec_boxes") or []
+                for text, score, box in zip(texts, scores, boxes):
+                    if not text:
+                        continue
+                    if box is not None and len(box) == 4 and not hasattr(box[0], "__len__"):
+                        flat = [float(v) for v in box]  # flat [x1,y1,x2,y2]
+                    else:
+                        flat = []
+                        for point in box:
+                            # points may be list/tuple/ndarray
+                            if hasattr(point, "__len__") and len(point) >= 2:
+                                flat.append(float(point[0]))
+                                flat.append(float(point[1]))
+                    if len(flat) < 4:
+                        continue
+                    xs = flat[0::2]
+                    ys = flat[1::2]
+                    items.append({
+                        "text": str(text),
+                        "confidence": round(float(score), 4),
+                        "box": [int(min(xs)), int(min(ys)), int(max(xs)), int(max(ys))],
+                    })
+        except Exception as exc:  # noqa: BLE001
+            print(json.dumps({"error": f"ocr failed (3.x): {exc}"}))
+            return 1
+    else:
+        # PaddleOCR 2.x API.
+        try:
+            result = ocr.ocr(image, cls=True)
+            for line in result or []:
+                for entry in line or []:
+                    box, text_conf = entry[0], entry[1]
+                    text, score = text_conf
+                    if not text:
+                        continue
+                    xs = [float(p[0]) for p in box]
+                    ys = [float(p[1]) for p in box]
+                    items.append({
+                        "text": str(text),
+                        "confidence": round(float(score), 4),
+                        "box": [int(min(xs)), int(min(ys)), int(max(xs)), int(max(ys))],
+                    })
+        except Exception as exc:  # noqa: BLE001
+            print(json.dumps({"error": f"ocr failed (2.x): {exc}"}))
+            return 1
+
+    print(json.dumps({"items": items}))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())