@anionex/dsh-computer-use 0.1.0

package/scripts/model-e2e.mjs

@@ -0,0 +1,291 @@
+#!/usr/bin/env node
+
+import { spawn } from 'node:child_process'
+import { access, mkdir, mkdtemp, readFile, readdir, rm, writeFile } from 'node:fs/promises'
+import { constants } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { dirname, join, resolve } from 'node:path'
+import { setTimeout as delay } from 'node:timers/promises'
+import { fileURLToPath } from 'node:url'
+import { findComputerClickEvidence } from './session-transcript.mjs'
+
+const ROOT = dirname(fileURLToPath(new URL('../package.json', import.meta.url)))
+const HELPER = join(ROOT, 'native', 'macos', 'bin', 'dsh-computer-use-helper')
+const FIXTURE_APP = join(ROOT, 'native', 'macos', 'fixture', 'DSHComputerUseFixture.app')
+const BUNDLE_ID = 'io.anionex.dsh-computer-use-fixture'
+const RESULTS = []
+const TEMPORARY = []
+
+function parseArgs(argv) {
+  const options = { keepTemp: false, output: undefined }
+  const values = [...argv]
+  while (values.length > 0) {
+    const option = values.shift()
+    if (option === '--keep-temp') options.keepTemp = true
+    else if (option === '--output') {
+      const value = values.shift()
+      if (value === undefined) throw new Error('--output needs a value')
+      options.output = resolve(value)
+    } else throw new Error(`unknown option: ${option}`)
+  }
+  return options
+}
+
+function requiredEnvironment(name) {
+  const value = process.env[name]?.trim()
+  if (!value) throw new Error(`${name} is required for the real-model lane`)
+  return value
+}
+
+function tail(value, length = 8000) {
+  return value.length <= length ? value : value.slice(-length)
+}
+
+async function runCommand(name, command, args, options = {}) {
+  const startedAt = Date.now()
+  const result = await new Promise((resolveResult) => {
+    const child = spawn(command, args, {
+      cwd: options.cwd ?? ROOT,
+      env: { ...process.env, ...options.env },
+      stdio: ['ignore', 'pipe', 'pipe'],
+    })
+    let stdout = ''
+    let stderr = ''
+    let timedOut = false
+    child.stdout.setEncoding('utf8').on('data', value => { stdout += value })
+    child.stderr.setEncoding('utf8').on('data', value => { stderr += value })
+    const timer = setTimeout(() => {
+      timedOut = true
+      child.kill('SIGKILL')
+    }, options.timeoutMs ?? 600_000)
+    child.once('error', error => {
+      clearTimeout(timer)
+      resolveResult({ code: -1, stdout, stderr: `${stderr}${error.message}`, timedOut })
+    })
+    child.once('close', code => {
+      clearTimeout(timer)
+      resolveResult({ code: code ?? -1, stdout, stderr, timedOut })
+    })
+  })
+  const evidence = {
+    name,
+    status: result.code === 0 && !result.timedOut ? 'pass' : result.timedOut ? 'timeout' : 'fail',
+    command: [command, ...args],
+    durationMs: Date.now() - startedAt,
+    code: result.code,
+    stdout: tail(result.stdout),
+    stderr: tail(result.stderr),
+  }
+  RESULTS.push(evidence)
+  if (evidence.status !== 'pass') {
+    throw new Error(`${name} ${evidence.status} (exit ${result.code})\n${evidence.stderr || evidence.stdout}`)
+  }
+  return result
+}
+
+async function helper(request) {
+  return await new Promise((resolveResult, reject) => {
+    const child = spawn(HELPER, [], { detached: true, stdio: ['pipe', 'pipe', 'pipe'] })
+    let stdout = ''
+    let stderr = ''
+    const timer = setTimeout(() => {
+      child.kill('SIGKILL')
+      reject(new Error('native helper timed out'))
+    }, 15_000)
+    child.stdout.setEncoding('utf8').on('data', value => { stdout += value })
+    child.stderr.setEncoding('utf8').on('data', value => { stderr += value })
+    child.once('error', error => { clearTimeout(timer); reject(error) })
+    child.once('close', () => {
+      clearTimeout(timer)
+      try {
+        const envelope = JSON.parse(stdout)
+        if (!envelope.ok || envelope.value === undefined) {
+          reject(new Error(`${envelope.error?.code}: ${envelope.error?.message}`))
+        } else resolveResult(envelope.value)
+      } catch (error) {
+        reject(new Error(`invalid helper response: ${stdout || stderr}`, { cause: error }))
+      }
+    })
+    child.stdin.end(`${JSON.stringify({ protocolVersion: 1, ...request })}\n`)
+  })
+}
+
+async function fixtureApps() {
+  const apps = await helper({ command: 'list-apps' })
+  return apps.filter(app => app.bundleId === BUNDLE_ID)
+}
+
+async function terminateFixtures() {
+  for (const app of await fixtureApps()) {
+    try { process.kill(app.pid, 'SIGTERM') } catch {}
+  }
+  const deadline = Date.now() + 5000
+  while ((await fixtureApps()).length > 0 && Date.now() < deadline) await delay(50)
+  if ((await fixtureApps()).length > 0) throw new Error('fixture processes did not terminate')
+}
+
+async function launchFixture(transcript) {
+  await runCommand(
+    'launch deterministic fixture without foreground activation',
+    'open',
+    ['-g', '-n', FIXTURE_APP, '--args', '--background', '--transcript', transcript],
+    { timeoutMs: 10_000 },
+  )
+  const deadline = Date.now() + 10_000
+  while (Date.now() < deadline) {
+    const [app] = await fixtureApps()
+    if (app !== undefined) return app
+    await delay(50)
+  }
+  throw new Error('fixture did not launch')
+}
+
+async function screenshotFiles(directory) {
+  try {
+    const files = await readdir(directory, { recursive: true })
+    return files.filter(file => file.endsWith('.png'))
+  } catch {
+    return []
+  }
+}
+
+async function findTarball(directory) {
+  const files = (await readdir(directory)).filter(file => file.endsWith('.tgz'))
+  if (files.length !== 1) throw new Error(`expected one tarball in ${directory}, found ${files.length}`)
+  return join(directory, files[0])
+}
+
+async function realModelWorkflow() {
+  const packing = await mkdtemp(join(tmpdir(), 'dsh-computer-model-pack-'))
+  const home = await mkdtemp(join(tmpdir(), 'dsh-computer-model-home-'))
+  const workspace = await mkdtemp(join(tmpdir(), 'dsh-computer-model-workspace-'))
+  const privateState = await mkdtemp(join(tmpdir(), 'dsh-computer-model-state-'))
+  TEMPORARY.push(packing, home, workspace, privateState)
+
+  await runCommand('pack dsh-computer-use', 'pnpm', ['pack', '--pack-destination', packing], { timeoutMs: 300_000 })
+  await access(HELPER, constants.X_OK)
+  await access(join(FIXTURE_APP, 'Contents', 'MacOS', 'DSHComputerUseFixture'), constants.X_OK)
+  const health = await helper({ command: 'health' })
+  if (health.accessibility !== 'granted' || health.screenRecording !== 'granted') {
+    throw new Error(`real-model lane requires macOS TCC grants: ${JSON.stringify(health)}`)
+  }
+
+  const tarball = await findTarball(packing)
+  await runCommand(
+    'install dsh-computer-use tarball',
+    'dsh',
+    ['plugin', '--profile', 'headless', 'add', tarball],
+    { env: { DSH_HOME: home }, timeoutMs: 180_000 },
+  )
+  const dump = await runCommand(
+    'dump real-model Profile',
+    'dsh',
+    ['--profile', 'headless', '--dump-config'],
+    { env: { DSH_HOME: home }, timeoutMs: 60_000 },
+  )
+  if (!dump.stdout.includes("name: '@anionex/dsh-computer-use'")) {
+    throw new Error('real-model Profile does not mount dsh-computer-use')
+  }
+
+  await terminateFixtures()
+  const transcript = join(privateState, 'fixture-transcript.json')
+  const app = await launchFixture(transcript)
+  const patch = join(home, 'computer-use-model.patch.yml')
+  await writeFile(patch, [
+    '- id: computer-use',
+    '  config:',
+    '    settleMs: 50',
+    '    maxSettleMs: 3000',
+    '    grants:',
+    `      - bundleId: ${BUNDLE_ID}`,
+    '        read: true',
+    '        control: true',
+    '- id: session-title-llm',
+    '  disabled: true',
+    '',
+  ].join('\n'))
+
+  const prompt = `/computer-use\n\nUse the dsh-computer-use capability to operate the running deterministic macOS fixture whose bundle id is ${BUNDLE_ID}. Load the Skill, list running applications, select the exact fixture process, observe it with a required screenshot and full Accessibility state, locate the element labelled "Targeted pointer probe", and click that current element using its observation id and element index with allowCoordinateFallback=true. Confirm from the fresh post-action observation that the status reads "Status: pointer click". Use only the focused computer-use Tools for UI observation and input; do not use shell, AppleScript, JXA, direct file edits, or coordinate guessing. Finish immediately after confirming the pointer-click state.`
+  const result = await runCommand(
+    'DeepSeek V4 computer-use fixture workflow',
+    'dsh',
+    ['run', '--profile', 'headless', '--patch', patch, prompt],
+    {
+      cwd: workspace,
+      env: {
+        DSH_HOME: home,
+        DSH_TELEMETRY_DISABLED: '1',
+        DSH_PERMISSION_MODE: 'workspace-write',
+        DEEPSEEK_API_KEY: requiredEnvironment('DEEPSEEK_API_KEY'),
+        DEEPSEEK_BASE_URL: process.env.DEEPSEEK_BASE_URL?.trim() || 'https://api.deepseek.com/v1',
+      },
+      timeoutMs: 600_000,
+    },
+  )
+
+  const state = JSON.parse(await readFile(transcript, 'utf8'))
+  if (state.activationCount !== 0 || state.pointerClickCount !== 1 || state.status !== 'Status: pointer click') {
+    throw new Error(`fixture state did not prove the requested action: ${JSON.stringify(state)}`)
+  }
+  const screenshots = await screenshotFiles(join(workspace, '.dsh-computer-use', 'artifacts'))
+  if (screenshots.length === 0) throw new Error('computer_observe produced no screenshot Artifact')
+  const evidence = await findComputerClickEvidence(join(home, 'sessions'))
+  if (!evidence.allowCoordinateFallback
+      || evidence.activation !== 'not-requested'
+      || evidence.pointerInput !== true
+      || evidence.pointerRouting !== 'target-process') {
+    throw new Error(`real-model transcript did not expose the target-process action evidence: ${JSON.stringify(evidence)}`)
+  }
+  RESULTS.push({
+    name: 'DeepSeek V4 computer-use assertions',
+    status: 'pass',
+    bundleId: app.bundleId,
+    pid: app.pid,
+    fixtureState: state,
+    toolEvidence: evidence,
+    screenshotArtifacts: screenshots,
+    finalResponse: tail(result.stdout.trim(), 2000),
+  })
+}
+
+async function writeOutput(options, value) {
+  const text = `${JSON.stringify(value, null, 2)}\n`
+  if (options.output !== undefined) {
+    await mkdir(dirname(options.output), { recursive: true })
+    await writeFile(options.output, text)
+  }
+  process.stdout.write(text)
+}
+
+let options
+let failure
+let cleanupFailure
+try {
+  options = parseArgs(process.argv.slice(2))
+  requiredEnvironment('DEEPSEEK_API_KEY')
+  await realModelWorkflow()
+} catch (error) {
+  failure = error instanceof Error ? error.message : String(error)
+} finally {
+  try {
+    if (await access(HELPER, constants.X_OK).then(() => true, () => false)) await terminateFixtures()
+    if (options?.keepTemp !== true) {
+      for (const path of TEMPORARY.reverse()) await rm(path, { recursive: true, force: true })
+    }
+  } catch (error) {
+    cleanupFailure = error instanceof Error ? error.message : String(error)
+  }
+}
+
+const report = {
+  schemaVersion: 1,
+  project: '@anionex/dsh-computer-use',
+  lane: 'real-model',
+  ok: failure === undefined && cleanupFailure === undefined,
+  failure: failure ?? null,
+  cleanup: cleanupFailure === undefined ? options?.keepTemp === true ? 'kept' : 'complete' : 'failed',
+  cleanupFailure: cleanupFailure ?? null,
+  results: RESULTS,
+}
+await writeOutput(options ?? {}, report)
+if (!report.ok) process.exitCode = 1

package/scripts/session-transcript.mjs

@@ -0,0 +1,117 @@
+import { readFile, readdir } from 'node:fs/promises'
+import { join } from 'node:path'
+import { promisify } from 'node:util'
+import { zstdDecompress } from 'node:zlib'
+
+const ZSTD_MAGIC = 0xFD2FB528
+const decompressZstd = promisify(zstdDecompress)
+
+function zstdFrames(buffer) {
+  const frames = []
+  let offset = 0
+  while (offset < buffer.length) {
+    const start = offset
+    if (buffer.length - offset < 5 || buffer.readUInt32LE(offset) !== ZSTD_MAGIC) {
+      throw new Error(`invalid Zstandard session frame at byte ${offset}`)
+    }
+    offset += 4
+    const descriptor = buffer.readUInt8(offset++)
+    if ((descriptor & 0x18) !== 0) throw new Error(`invalid Zstandard frame descriptor at byte ${offset - 1}`)
+    const contentSizeFlag = descriptor >>> 6
+    const singleSegment = (descriptor & 0x20) !== 0
+    const checksum = (descriptor & 0x04) !== 0
+    const dictionaryFlag = descriptor & 0x03
+    const dictionaryBytes = dictionaryFlag === 3 ? 4 : dictionaryFlag
+    const contentSizeBytes = contentSizeFlag === 0 ? (singleSegment ? 1 : 0) : 1 << contentSizeFlag
+    const headerBytes = (singleSegment ? 0 : 1) + dictionaryBytes + contentSizeBytes
+    if (buffer.length - offset < headerBytes) throw new Error(`truncated Zstandard session frame at byte ${start}`)
+    offset += headerBytes
+    for (;;) {
+      if (buffer.length - offset < 3) throw new Error(`truncated Zstandard session frame at byte ${start}`)
+      const blockHeader = buffer.readUIntLE(offset, 3)
+      offset += 3
+      const lastBlock = (blockHeader & 1) !== 0
+      const blockType = (blockHeader >>> 1) & 0x03
+      const blockSize = blockHeader >>> 3
+      if (blockType === 0x03) throw new Error(`invalid Zstandard block at byte ${offset - 3}`)
+      const payloadBytes = blockType === 0x01 ? 1 : blockSize
+      if (buffer.length - offset < payloadBytes) throw new Error(`truncated Zstandard session frame at byte ${start}`)
+      offset += payloadBytes
+      if (lastBlock) break
+    }
+    if (checksum) {
+      if (buffer.length - offset < 4) throw new Error(`truncated Zstandard checksum at byte ${start}`)
+      offset += 4
+    }
+    frames.push(buffer.subarray(start, offset))
+  }
+  return frames
+}
+
+async function sessionLogs(directory) {
+  const result = []
+  for (const entry of await readdir(directory, { withFileTypes: true }).catch(() => [])) {
+    const path = join(directory, entry.name)
+    if (entry.isDirectory()) result.push(...await sessionLogs(path))
+    else if (entry.isFile() && (entry.name === 'session.jsonl' || entry.name === 'session.jsonl.zstd')) result.push(path)
+  }
+  return result
+}
+
+/** Read every JSON record from one plain or concatenated-frame DSH Session log. */
+export async function readSessionRecords(path) {
+  const encoded = await readFile(path)
+  const decoded = path.endsWith('.zstd')
+    ? Buffer.concat(await Promise.all(zstdFrames(encoded).map(frame => decompressZstd(frame))))
+    : encoded
+  return decoded.toString('utf8').split('\n').filter(Boolean).map(line => JSON.parse(line))
+}
+
+function resultValue(event) {
+  const outer = event?.data?.message?.content
+  if (!Array.isArray(outer)) return undefined
+  for (const block of outer) {
+    if (block?.type !== 'tool-result' || !Array.isArray(block.content)) continue
+    for (const content of block.content) {
+      if (content?.type !== 'text' || typeof content.text !== 'string') continue
+      try { return JSON.parse(content.text) }
+      catch { return undefined }
+    }
+  }
+  return undefined
+}
+
+/** Locate the durable model-visible result for the target-process pointer probe. */
+export async function findComputerClickEvidence(sessionRoot) {
+  const candidates = []
+  for (const path of await sessionLogs(sessionRoot)) {
+    const records = await readSessionRecords(path)
+    const header = records.find(record => record?.type === 'session')
+    const calls = new Map(records
+      .filter(record => record?.type === 'tool/call' && record?.data?.name === 'computer_click')
+      .map(record => [record.data.callId, record]))
+    for (const record of records) {
+      if (record?.type !== 'tool/result') continue
+      const callId = record?.data?.message?.source?.callId
+      const call = calls.get(callId)
+      if (call === undefined) continue
+      let args
+      try { args = JSON.parse(call.data.arguments) }
+      catch { continue }
+      const result = resultValue(record)
+      if (result?.action !== 'click') continue
+      candidates.push({
+        time: record.time ?? 0,
+        sessionId: header?.id,
+        callId,
+        allowCoordinateFallback: args.allowCoordinateFallback === true,
+        activation: result.activation,
+        pointerInput: result.pointerInput,
+        pointerRouting: result.pointerRouting,
+      })
+    }
+  }
+  const evidence = candidates.sort((left, right) => right.time - left.time)[0]
+  if (evidence === undefined) throw new Error('durable Session transcript contains no completed computer_click result')
+  return evidence
+}

package/scripts/validate.mjs

@@ -0,0 +1,256 @@
+#!/usr/bin/env node
+
+import { createHash } from 'node:crypto'
+import { spawn } from 'node:child_process'
+import { constants } from 'node:fs'
+import { access, mkdir, mkdtemp, readFile, readdir, realpath, rm, writeFile } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { dirname, join, resolve } from 'node:path'
+import { fileURLToPath, pathToFileURL } from 'node:url'
+
+const ROOT = dirname(fileURLToPath(new URL('../package.json', import.meta.url)))
+const results = []
+const temporaryPaths = []
+
+function parseArgs(argv) {
+  const options = {
+    lane: 'all',
+    allowHubWarning: false,
+    keepTemp: false,
+    output: undefined,
+  }
+  const values = [...argv]
+  while (values.length > 0) {
+    const option = values.shift()
+    if (option === '--allow-hub-warning') options.allowHubWarning = true
+    else if (option === '--keep-temp') options.keepTemp = true
+    else if (option === '--lane' || option === '--output') {
+      const value = values.shift()
+      if (value === undefined) throw new Error(`${option} needs a value`)
+      if (option === '--lane') options.lane = value
+      else options.output = resolve(value)
+    } else throw new Error(`unknown option: ${option}`)
+  }
+  if (!['local', 'profile', 'all'].includes(options.lane)) {
+    throw new Error(`--lane must be local, profile, or all; got ${options.lane}`)
+  }
+  return options
+}
+
+function tail(value, length = 6000) {
+  return value.length <= length ? value : value.slice(-length)
+}
+
+async function runCommand(name, command, args, options = {}) {
+  const startedAt = Date.now()
+  let final
+  for (let attempt = 1; attempt <= (options.retries ?? 0) + 1; attempt += 1) {
+    final = await new Promise((resolveResult) => {
+      const child = spawn(command, args, {
+        cwd: options.cwd ?? ROOT,
+        env: { ...process.env, ...options.env },
+        stdio: ['ignore', 'pipe', 'pipe'],
+      })
+      let stdout = ''
+      let stderr = ''
+      let timedOut = false
+      child.stdout.setEncoding('utf8').on('data', value => { stdout += value })
+      child.stderr.setEncoding('utf8').on('data', value => { stderr += value })
+      const timer = setTimeout(() => {
+        timedOut = true
+        child.kill('SIGKILL')
+      }, options.timeoutMs ?? 120_000)
+      child.once('error', (error) => {
+        clearTimeout(timer)
+        resolveResult({ code: -1, stdout, stderr: `${stderr}${error.message}`, timedOut, attempt })
+      })
+      child.once('close', (code) => {
+        clearTimeout(timer)
+        resolveResult({ code: code ?? -1, stdout, stderr, timedOut, attempt })
+      })
+    })
+    if (final.code === 0 && !final.timedOut) break
+  }
+  const result = {
+    name,
+    status: final.code === 0 && !final.timedOut ? 'pass' : final.timedOut ? 'timeout' : 'fail',
+    command: [command, ...args],
+    attempts: final.attempt,
+    durationMs: Date.now() - startedAt,
+    code: final.code,
+    stdout: tail(final.stdout),
+    stderr: tail(final.stderr),
+  }
+  results.push(result)
+  if (result.status !== 'pass') {
+    throw new Error(`${name} ${result.status} (exit ${result.code})\n${result.stderr || result.stdout}`)
+  }
+  return final
+}
+
+async function executable(name) {
+  for (const directory of (process.env.PATH ?? '').split(':').filter(Boolean)) {
+    const candidate = join(directory, name)
+    try {
+      await access(candidate, constants.X_OK)
+      return candidate
+    } catch {
+      // Continue PATH lookup.
+    }
+  }
+  throw new Error(`required executable is unavailable: ${name}`)
+}
+
+async function dshSourceRoot() {
+  const dsh = await realpath(await executable('dsh'))
+  let candidate = dirname(dsh)
+  for (let depth = 0; depth < 6; depth += 1) {
+    try {
+      await access(join(candidate, 'apps', 'cli', 'config', 'agent-presets', 'standard'))
+      return await realpath(candidate)
+    } catch {
+      const parent = dirname(candidate)
+      if (parent === candidate) break
+      candidate = parent
+    }
+  }
+  throw new Error(`cannot infer DSH source root from ${dsh}`)
+}
+
+async function pluginCheck(options) {
+  const sourceRoot = await dshSourceRoot()
+  const checkout = await mkdtemp(join(tmpdir(), 'dsh-computer-plugin-check-'))
+  temporaryPaths.push(checkout)
+  await runCommand(
+    'clone dsh-plugin-check',
+    'gh',
+    ['repo', 'clone', 'dsh-external/dsh-plugin-check', checkout, '--', '--depth=1'],
+    { timeoutMs: 60_000, retries: 1 },
+  )
+  const code = [
+    `const { checkRepo } = await import(${JSON.stringify(pathToFileURL(join(checkout, 'src', 'index.ts')).href)});`,
+    `const report = await checkRepo(${JSON.stringify(ROOT)}, false);`,
+    'console.log(JSON.stringify(report));',
+  ].join(' ')
+  const checked = await runCommand(
+    'dsh-plugin-check',
+    process.execPath,
+    ['--import', join(sourceRoot, 'node_modules', 'tsx', 'dist', 'esm', 'index.mjs'), '--input-type=module', '-e', code],
+    { env: { TSX_TSCONFIG_PATH: join(sourceRoot, 'tsconfig.json') }, timeoutMs: 30_000 },
+  )
+  const report = JSON.parse(checked.stdout.trim())
+  const warnings = report.warnings ?? []
+  const allowed = options.allowHubWarning && warnings.every(warning => warning.code === 'not-in-hub')
+  if (report.errors?.length > 0 || (warnings.length > 0 && !allowed)) {
+    throw new Error(`dsh-plugin-check did not pass cleanly: ${JSON.stringify(report, null, 2)}`)
+  }
+  results.push({
+    name: 'dsh-plugin-check assertion',
+    status: 'pass',
+    verdict: report.verdict,
+    allowedWarnings: allowed ? warnings : [],
+    checks: report.checks,
+  })
+}
+
+async function javascriptFiles(directory) {
+  const paths = []
+  for (const entry of await readdir(directory, { withFileTypes: true })) {
+    const path = join(directory, entry.name)
+    if (entry.isDirectory()) paths.push(...await javascriptFiles(path))
+    else if (entry.isFile() && entry.name.endsWith('.js')) paths.push(path)
+  }
+  return paths
+}
+
+async function portableAssertions() {
+  const startedAt = Date.now()
+  const pkg = JSON.parse(await readFile(join(ROOT, 'package.json'), 'utf8'))
+  if (pkg.dsh?.bundle?.patch !== './cordis.patch.yml') throw new Error('package is missing dsh.bundle.patch')
+  if (pkg.dsh?.client?.platform !== 'web' || pkg.dshClient !== undefined) throw new Error('package must use dsh.client and omit dshClient')
+  for (const group of ['dependencies', 'devDependencies', 'peerDependencies', 'optionalDependencies']) {
+    for (const [name, spec] of Object.entries(pkg[group] ?? {})) {
+      if (typeof spec !== 'string' || /^(?:file:|link:|workspace:|\/|[A-Za-z]:[\\/])/u.test(spec) || spec.includes('/Users/')) {
+        throw new Error(`${group}.${name} is machine-local: ${String(spec)}`)
+      }
+    }
+  }
+  for (const path of await javascriptFiles(join(ROOT, 'lib'))) {
+    const source = await readFile(path, 'utf8')
+    if (/from ['"]\.\.?\/[^'"]+\.ts['"]/u.test(source)) throw new Error(`built JavaScript imports TypeScript: ${path}`)
+  }
+  const client = await readFile(join(ROOT, 'lib', 'client.js'), 'utf8')
+  if (!client.includes('window.__ModuleLoader__.load')) throw new Error('lib/client.js is not loader-compatible')
+  const manifest = JSON.parse(await readFile(join(ROOT, 'native', 'macos', 'manifest.json'), 'utf8'))
+  const helper = await readFile(join(ROOT, 'native', 'macos', manifest.binary.path))
+  const digest = createHash('sha256').update(helper).digest('hex')
+  if (digest !== manifest.binary.sha256) throw new Error('native helper hash does not match manifest')
+  if (JSON.stringify(manifest.binary.architectures) !== JSON.stringify(['arm64', 'x86_64'])) {
+    throw new Error(`native helper architectures are not universal: ${JSON.stringify(manifest.binary.architectures)}`)
+  }
+  results.push({
+    name: 'portable artifact assertions',
+    status: 'pass',
+    durationMs: Date.now() - startedAt,
+    helperSha256: digest,
+    architectures: manifest.binary.architectures,
+    minimumMacOS: manifest.binary.minimumMacOS,
+  })
+}
+
+async function localLane(options) {
+  await runCommand('build', 'pnpm', ['run', 'build'], { timeoutMs: 300_000 })
+  await runCommand(
+    'unit and native fixture tests',
+    'pnpm',
+    ['exec', 'vitest', 'run', 'tests', '--exclude', 'tests/profile-install.e2e.spec.ts'],
+    { env: { DSH_COMPUTER_USE_REQUIRE_TCC: '1' }, timeoutMs: 600_000 },
+  )
+  await portableAssertions()
+  await runCommand('pack dry run', 'pnpm', ['pack', '--dry-run'], { timeoutMs: 300_000 })
+  await pluginCheck(options)
+}
+
+async function profileLane() {
+  await runCommand(
+    'clean Web/Headless Profile fixture E2E',
+    'pnpm',
+    ['exec', 'vitest', 'run', 'tests/profile-install.e2e.spec.ts'],
+    { env: { DSH_COMPUTER_USE_REQUIRE_TCC: '1' }, timeoutMs: 420_000 },
+  )
+}
+
+async function writeOutput(options, value) {
+  const text = `${JSON.stringify(value, null, 2)}\n`
+  if (options.output !== undefined) {
+    await mkdir(dirname(options.output), { recursive: true })
+    await writeFile(options.output, text)
+  }
+  process.stdout.write(text)
+}
+
+let options
+let failure
+try {
+  options = parseArgs(process.argv.slice(2))
+  if (options.lane === 'local' || options.lane === 'all') await localLane(options)
+  if (options.lane === 'profile' || options.lane === 'all') await profileLane()
+} catch (error) {
+  failure = error instanceof Error ? error.message : String(error)
+} finally {
+  if (options?.keepTemp !== true) {
+    for (const path of temporaryPaths.reverse()) await rm(path, { recursive: true, force: true })
+  }
+}
+
+const report = {
+  schemaVersion: 1,
+  project: '@anionex/dsh-computer-use',
+  lane: options?.lane ?? null,
+  ok: failure === undefined,
+  failure: failure ?? null,
+  cleanup: options?.keepTemp === true ? 'kept' : 'complete',
+  results,
+}
+await writeOutput(options ?? {}, report)
+if (failure !== undefined) process.exitCode = 1

package/src/approval-policy.ts

@@ -0,0 +1,16 @@
+/** Shared DSH approval-policy read for Computer Use permission paths. */
+
+import type { Agent } from '@deepseek-ai/dsh-agent'
+import type { ApprovalPolicy } from '@deepseek-ai/dsh-user-approval'
+import type { Context } from '@deepseek-ai/cordis'
+
+/**
+ * The session's effective DSH approval policy: a logged override, else the
+ * approval plugin's configured default.
+ * @param ctx - context with the approval service injected.
+ * @param agent - the agent whose session policy applies.
+ * @returns `'never'` when every approval ask would auto-reject without a prompt.
+ */
+export function approvalPolicy(ctx: Context, agent: Agent): ApprovalPolicy {
+  return ctx.approval.overrideOf(agent.session) ?? ctx.approval.config.policy ?? 'ask'
+}