dsh-codex-style-computer-use 1.2.0-rc.3

package/lib/attention.js

@@ -0,0 +1,140 @@
+import { AttentionNative } from './attention-native.js'
+
+// Pure event wiring + a separately testable native boundary. Never handles answers or approvals.
+export function installHumanAttention (ctx, log, options = {}) {
+  let raise = null
+  const native = options.native || new AttentionNative()
+  // Official 0.2.x launches dsh-desktop-host as Electron's Node child and does NOT
+  // register the legacy desktopRuntime Cordis service. Waiting for it disables ALL listeners.
+  const nativeHost = options.nativeHost ?? (process.platform === 'win32' &&
+    process.argv.some(arg => String(arg).replaceAll('\\', '/').includes('/dsh-desktop-host/')))
+  native.log({ stage: 'installer-enter', nativeHost, pid: process.pid, argvEntry: process.argv[1],
+    electronNodeMode: process.env.ELECTRON_RUN_AS_NODE === '1' })
+  const install = desktopCtx => {
+    if (raise) return
+    let runtime
+    // Cordis' property proxy may throw for an unregistered service; optional chaining
+    // on that property is insufficient. get() is the optional service lookup API.
+    try { runtime = typeof desktopCtx.get === 'function' ? desktopCtx.get('desktopRuntime') : desktopCtx.desktopRuntime } catch {}
+    if (typeof runtime?.show !== 'function' && !nativeHost) { log.warn('human attention: desktopRuntime.show unavailable'); return }
+    const now = options.now || Date.now
+    const pending = new Map(), inFlight = new Map(), recent = new Map(), questionKeys = new WeakMap()
+    let anonymous = 0, disposed = false
+    const record = data => native.log(data)
+    const trim = map => { while (map.size > 256) map.delete(map.keys().next().value) }
+    const bounded = (promise, ms) => new Promise((resolve, reject) => {
+      const timer = setTimeout(() => reject(new Error(`show timed out (${ms}ms)`)), ms)
+      Promise.resolve(promise).then(v => { clearTimeout(timer); resolve(v) }, e => { clearTimeout(timer); reject(e) })
+    })
+    native.start().catch(error => record({ stage: 'prewarm-failed', error: error.stack || String(error) }))
+    raise = (key, what, stillPending = () => true) => {
+      if (disposed) return Promise.resolve(false)
+      key ||= `anon:${++anonymous}`
+      if (inFlight.has(key)) return inFlight.get(key)
+      if (recent.has(key) && now() - recent.get(key) < 1500) return Promise.resolve(true)
+      const started = performance.now()
+      const work = (async () => {
+        record({ stage: 'raise-start', key, what })
+        let before, probeError
+        try { before = await native.request('probe') } catch (e) { probeError = e.message }
+        if (disposed || !stillPending()) {
+          record({ stage: 'raise-cancelled', key, what })
+          return false
+        }
+        if (before?.focused && before?.sampledVisible) {
+          record({ stage: 'raise-result', key, what, status: 'already-visible', visible: true, focused: true, elapsedMs: Math.round(performance.now() - started) })
+          log.info(`Desktop already in front for ${what}`)
+          return true
+        }
+        // The host request and the independent visibility fallback run together. A rejected/hung
+        // host RPC must not suppress the fallback or delay the card waterfall.
+        let show
+        try { show = typeof runtime?.show === 'function'
+          ? bounded(runtime.show(), 150).then(() => 'requested', e => `error: ${e.message}`)
+          : Promise.resolve('unavailable-native-fallback') }
+        catch (e) { show = Promise.resolve(`error: ${e.message}`) }
+        let result
+        try { result = await native.request('raise') }
+        catch (error) {
+          record({ stage: 'raise-result', key, what, status: 'error', visible: false, probeError, show: await show, error: error.stack || String(error), elapsedMs: Math.round(performance.now() - started) })
+          log.warn(`could not reveal Desktop for ${what}: ${error.message}`)
+          return false
+        }
+        const elapsedMs = Math.round(performance.now() - started)
+        record({ stage: 'raise-result', key, what, ...result, show: await show, probeError, elapsedMs, within1s: result.visible === true && elapsedMs <= 1000 })
+        if (result.visible === true) log.info(`Desktop ${result.focused ? 'foreground' : 'visible without focus'} CONFIRMED for ${what} (${elapsedMs}ms)`)
+        else log.warn(`could not reveal Desktop for ${what}: ${result.status}; flash=${result.flash || 'unknown'}`)
+        return result.visible === true
+      })().catch(error => { record({ stage: 'raise-error', key, error: error.stack || String(error) }); return false })
+      inFlight.set(key, work)
+      work.then(ok => { inFlight.delete(key); if (ok) { recent.set(key, now()); trim(recent) } })
+      return work
+    }
+    const schedule = (key, what) => {
+      const previous = pending.get(key)
+      if (previous && (!previous.exhausted || inFlight.has(key))) return
+      const item = { timer: null, attempts: 0 }
+      pending.set(key, item)
+      const attempt = async () => {
+        if (disposed || pending.get(key) !== item) return
+        item.attempts++
+        const ok = await raise(key, what, () => pending.get(key) === item)
+        if (!ok && item.attempts < 2 && pending.get(key) === item && !disposed) {
+          item.timer = setTimeout(attempt, options.retryMs ?? 700)
+          item.timer.unref?.()
+          record({ stage: 'retry-scheduled', key })
+        }
+        if (!ok && item.attempts >= 2) item.exhausted = true
+      }
+      void attempt()
+    }
+    const finish = key => {
+      const item = pending.get(key)
+      if (item) clearTimeout(item.timer)
+      pending.delete(key)
+    }
+    const question = (...args) => {
+      const next = args[args.length - 1]
+      const request = args.find(a => a && typeof a === 'object' && Array.isArray(a.questions)) || {}
+      let key = questionKeys.get(request)
+      if (!key) {
+        const ids = (request.questions || []).map(q => q?.id).filter(Boolean).join(',')
+        key = `q:${ids}#${++anonymous}`
+        questionKeys.set(request, key)
+      }
+      schedule(key, `pending question (${(request.questions || []).length} question(s))`)
+      // Preserve the original waterfall result, including rejecting promises.
+      let answer
+      try { answer = typeof next === 'function' ? next() : undefined }
+      catch (e) { finish(key); throw e }
+      if (answer?.then) answer.then(() => finish(key), () => finish(key))
+      else finish(key)
+      return answer
+    }
+    const approval = (session, event) => {
+      const id = event?.data?.id
+      if (typeof id !== 'string' || !id) return
+      const key = `a:${typeof session === 'string' ? session : session?.id || ''}:${id}`
+      if (event.type === 'approval/decided') { finish(key); return }
+      if (event.type === 'approval/asked') schedule(key, `pending approval ${id} (${event.data.toolName || 'tool'})`)
+    }
+    for (const target of new Set([ctx, desktopCtx])) {
+      target.on('user-questions/request', question, { prepend: true })
+      target.on('session/event', approval, { prepend: true })
+    }
+    desktopCtx.on('dispose', () => {
+      disposed = true
+      for (const key of pending.keys()) finish(key)
+      void native.close()
+    })
+    record({ stage: 'installed', hostMode: nativeHost ? 'official-desktop-native' : 'legacy-desktop-runtime', pid: process.pid, execPath: process.execPath })
+    log.info('human attention enabled: foreground, measured visibility, flash request, persistent diagnostics')
+  }
+  if (nativeHost) install(ctx)
+  else ctx.inject(['desktopRuntime'], install)
+  return (key, what) => {
+    if (raise) return raise(key, what)
+    log.warn(`human attention: desktopRuntime not ready for ${what}`)
+    return Promise.resolve(false)
+  }
+}

package/lib/audit.js

@@ -0,0 +1,30 @@
+// audit.js — snapshot paths + JSONL audit trail for dsh-computer-use.
+// Every actuation the core emits lands here: {ts, op, args(redacted), result?|error?}.
+// Screenshots taken before risky ops (v1) will join the same stream.
+
+import { appendFileSync, mkdirSync, existsSync } from 'node:fs'
+import { join } from 'node:path'
+import { homedir } from 'node:os'
+import { randomUUID } from 'node:crypto'
+
+export function mkDataDir (configured) {
+  const dshHome = process.env.DSH_HOME || join(homedir(), '.dsh')
+  const dir = configured && configured.length > 0
+    ? configured
+    : join(dshHome, 'data', 'computer-use')
+  const shots = join(dir, 'shots')
+  if (!existsSync(shots)) mkdirSync(shots, { recursive: true })
+  return { root: dir, shots }
+}
+
+export function snapshotPath (dataDir) {
+  const ts = new Date().toISOString().replace(/[:.]/g, '-').replace('T', '_').slice(0, 19)
+  const ms = Date.now() % 1000
+  return join(dataDir.shots, `shot-${ts}-${ms}-${randomUUID()}.jpg`)
+}
+
+export function appendAudit (dataDir, rec) {
+  try {
+    appendFileSync(join(dataDir.root, 'audit.jsonl'), JSON.stringify(rec) + '\n')
+  } catch { /* audit must never break the action */ }
+}

package/lib/batch.js

@@ -0,0 +1,52 @@
+// Serial execution and observation selection; no desktop or lifecycle side effects here.
+const reads = new Set(['computer_state', 'computer_uia', 'computer_marks', 'computer_shot', 'computer_wait'])
+const isRead = (step) => reads.has(step?.tool) || (step?.tool === 'computer_clip' && step.args?.text === undefined)
+const isReadback = (step) => ['computer_state', 'computer_uia', 'computer_marks', 'computer_shot'].includes(step.tool) ||
+  (step.tool === 'computer_clip' && step.args?.text === undefined)
+
+export function actionRefusal (step, result) {
+  if (result?.ok === false || result?.success === false) return result.error || 'action reported failure'
+  if (step.tool === 'computer_window' && (step.args?.op || 'activate') === 'activate' && result?.activated !== true) {
+    return 'target window activation was not confirmed; subsequent actions were not dispatched'
+  }
+  if (step.tool === 'computer_ctrl' && step.args?.action === 'recover' && result?.recovered !== true) return result.reason || 'temporary pause recovery refused'
+  return null
+}
+
+export async function runBatch ({ steps, handlers, signal, stopped, screenshot, shot = 'auto', exec }) {
+  if (!Array.isArray(steps) || !['auto', 'always', 'never'].includes(shot)) throw new Error('invalid batch actions or shot mode')
+  const actions = []
+  let failed = false
+  for (const step of steps) {
+    const name = step?.tool
+    if (failed || signal?.aborted) {
+      actions.push({ tool: name || '', ok: false, outcome: 'not-dispatched', error: signal?.aborted ? 'cancelled' : 'earlier action failed' })
+      failed = true
+      continue
+    }
+    const fn = Object.hasOwn(handlers, name) && handlers[name]
+    if (!fn) { actions.push({ tool: name || '', ok: false, outcome: 'not-dispatched', error: 'unknown tool' }); failed = true; continue }
+    try {
+      const stoppedBefore = stopped()
+      const result = await fn(step.args || {}, exec)
+      const refusal = actionRefusal(step, result)
+      actions.push({ tool: name, ok: !refusal, result, ...(refusal ? { error: refusal } : {}) })
+      failed = !!refusal || (!stoppedBefore && stopped()) ||
+        (name === 'computer_ctrl' && ['stop', 'exit'].includes(step.args?.action))
+    } catch (error) {
+      actions.push({ tool: name, ok: false, error: String(error.message || error),
+        code: error.code || 'action-error', outcome: error.outcome || 'unknown' })
+      failed = true
+    }
+  }
+  const needsShot = shot === 'always' || (shot === 'auto' && steps.some(s => !isRead(s)) && !isReadback(steps.at(-1) || {}))
+  const result = { actions, attachedShot: null }
+  if (!failed && !signal?.aborted && !stopped() && needsShot) {
+    try { result.attachedShot = await screenshot() }
+    catch (error) { result.observationError = String(error.message || error) }
+  }
+  // A transport/provider return does not prove that a form was saved or a message was sent.
+  if (steps.some(s => s && !isRead(s))) result.verification = 'Inspect returned readback or image before claiming the task effect; ok only means the action returned.'
+  if (result.attachedShot) result.view = 'read_image the attachedShot if visual verification is needed'
+  return result
+}

package/lib/bin/attention-worker.exe.json

@@ -0,0 +1,7 @@
+{
+  "format": 1,
+  "platform": "win32",
+  "architecture": "x64",
+  "sourceSha256": "6e17308fc1cb0de1ece6f3164866b6de03ecdf74a42a6e78c0a8e6d02912c3bf",
+  "binarySha256": "c15feb47d7ec975ccab12fea2ee4300ea0a4699069be21d0fb9d1fedebe26158"
+}

package/lib/core/bin/dsh-computer-use-worker.exe.json

@@ -0,0 +1,7 @@
+{
+  "format": 1,
+  "platform": "win32",
+  "architecture": "x64",
+  "sourceSha256": "7e24c3fa73fed54eb8209efc253753d44664037954d936573e7c80150caf5856",
+  "binarySha256": "ee890a28d1aec984f98b48caf30acab536477ea4d9261892761ea6e8bd485c46"
+}

package/lib/core/compile-worker.ps1

@@ -0,0 +1,58 @@
+param(
+    # RESOLVED FROM THIS SCRIPT'S OWN LOCATION, NOT FROM A MACHINE-SPECIFIC PATH (2026-09-16).
+    # It used to default to `D:\BuyKey\dsh-computer-use\packages\computer-use-core\src\worker.cs`, which is
+    # correct on exactly one computer — and `compileWorkerSync()` in index.js calls this script WITHOUT
+    # `-Path`, so on any other machine the plugin's compile-on-demand path pointed at a file that is not
+    # there. That is a silent portability failure: the plugin only reaches it when no cached worker exists,
+    # i.e. on a fresh install, i.e. on the machine that has never worked. `$PSScriptRoot` is the directory
+    # this file lives in, and `worker.cs` ships beside it.
+    [string]$Path = '',
+    [switch]$Force,
+    # OPTIONAL NAMESPACE FOR THE CACHE DIRECTORY. The cache key is the source's sha16, which is right
+    # for the deployed worker but wrong for a TEST SANDBOX: two runs of the same test compile identical
+    # sources, so they land on the SAME exe path, and a worker left running by an earlier run holds
+    # that file open — `csc` then fails with CS0016 ("cannot write output file") and a test that cannot
+    # rebuild its fault-injected worker silently has nothing to measure. Measured exactly that:
+    # build/test-ask-release.mjs alternated pass/fail depending on whether a stale sandbox worker from
+    # its own previous run was still alive. A caller that needs isolation passes a unique token (e.g.
+    # its own pid); the default is '' so the deployed worker's cache path is unchanged.
+    [string]$CacheToken = ''
+)
+if (-not $Path) { $Path = Join-Path $PSScriptRoot 'worker.cs' }
+# compile-worker.ps1 — turn worker.cs into a cached native worker.exe.
+# Uses ONLY the C# 5 compiler shipping with Windows (Framework64 csc.exe):
+# no SDK, no node-gyp, no network. C# source stays C#-5-compatible on purpose.
+# Cache: %LOCALAPPDATA%\dsh-computer-use\worker\<sha16>[<CacheToken>]\worker.exe
+$ErrorActionPreference = 'Stop'
+
+$cacheRoot = Join-Path $env:LOCALAPPDATA 'dsh-computer-use\worker'
+$sha = (Get-FileHash -LiteralPath $Path -Algorithm SHA256).Hash
+$outDir = Join-Path $cacheRoot ($sha.Substring(0, 16) + $CacheToken)
+$outExe = Join-Path $outDir 'dsh-computer-use-worker.exe'
+Write-Host "worker cache dir: $outDir"
+
+if ((Test-Path -LiteralPath $outExe) -and -not $Force) {
+    Write-Host 'cached worker is current; use -Force to recompile'
+    Write-Output $outExe
+    return
+}
+
+$csc = "$env:windir\Microsoft.NET\Framework64\v4.0.30319\csc.exe"
+if (-not (Test-Path -LiteralPath $csc)) { throw 'csc.exe not found (.NET Framework 4.x missing?)' }
+
+# csc does not resolve GAC simple names — pass full assembly paths
+$gac = "$env:windir\Microsoft.NET\assembly\GAC_MSIL"
+$refs = @(
+    '/r:System.dll', '/r:System.Core.dll', '/r:System.Drawing.dll',
+    '/r:System.Web.Extensions.dll', '/r:System.Windows.Forms.dll',
+    "/r:$gac\UIAutomationClient\v4.0_4.0.0.0__31bf3856ad364e35\UIAutomationClient.dll",
+    "/r:$gac\UIAutomationTypes\v4.0_4.0.0.0__31bf3856ad364e35\UIAutomationTypes.dll",
+    "/r:$gac\WindowsBase\v4.0_4.0.0.0__31bf3856ad364e35\WindowsBase.dll"
+)
+
+New-Item -ItemType Directory -Path $outDir -Force | Out-Null
+& $csc /nologo /target:exe /platform:x64 /optimize+ /warn:1 /out:$outExe $refs $Path
+if ($LASTEXITCODE -ne 0) { throw "csc failed with exit code $LASTEXITCODE" }
+if (-not (Test-Path -LiteralPath $outExe)) { throw 'compile produced no exe' }
+Write-Host "compiled OK -> $outExe"
+Write-Output $outExe