@aryacode/dsh-plugin-arya-computer-use 0.0.0-stage → 1.0.1

package/mcp/browser-launcher.mjs

@@ -0,0 +1,66 @@
+// MCP entry point for the web lane.
+//
+// DSH launches this file instead of agent-browser itself so the browser lane can
+// follow the plugin's settings (tool surface, Chrome profile, session, CDP
+// endpoint, headed window) without editing the Cordis patch by hand. The real
+// server's stdio is inherited, so this process is a transparent pipe: stdin and
+// stdout carry the MCP protocol untouched, and settings changes are picked up on
+// the next MCP restart.
+
+import { spawn } from 'node:child_process';
+import { existsSync, readFileSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+
+const require = createRequire(import.meta.url);
+const BIN = require.resolve('agent-browser/bin/agent-browser.js');
+
+function controlDir() {
+  const local = process.env.LOCALAPPDATA || join(homedir(), 'AppData', 'Local');
+  return join(local, 'dsh-plugin-arya-desktop', 'control');
+}
+
+function readSettings() {
+  const file = join(controlDir(), 'settings.json');
+  if (!existsSync(file)) return {};
+  try {
+    const parsed = JSON.parse(readFileSync(file, 'utf8'));
+    return parsed && typeof parsed === 'object' ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+
+const text = (value) => (typeof value === 'string' ? value.trim() : '');
+
+export function browserArgs(settings = {}) {
+  const args = [BIN, 'mcp'];
+  const tools = text(settings.browserTools);
+  if (tools) args.push('--tools', tools);
+  const cdp = text(settings.browserCdp);
+  const profile = text(settings.browserProfile);
+  const session = text(settings.browserSession);
+  const state = text(settings.browserStateFile);
+  if (cdp) args.push('--cdp', cdp);
+  if (profile) args.push('--profile', profile);
+  if (session) args.push('--session', session);
+  if (state) args.push('--state', state);
+  if (settings.browserHeaded === true) args.push('--headed');
+  return args;
+}
+
+function main() {
+  const args = browserArgs(readSettings());
+  const child = spawn(process.execPath, args, { stdio: 'inherit', windowsHide: true });
+  child.on('error', (error) => {
+    process.stderr.write(`arya browser lane: could not start agent-browser: ${error.message}\n`);
+    process.exit(1);
+  });
+  child.on('exit', (code, signal) => process.exit(code ?? (signal ? 1 : 0)));
+  for (const signal of ['SIGINT', 'SIGTERM', 'SIGHUP']) {
+    process.on(signal, () => { try { child.kill(signal); } catch { /* already gone */ } });
+  }
+}
+
+if (process.argv[1] && import.meta.url.endsWith(process.argv[1].replace(/\\/g, '/').split('/').pop())) main();

package/mcp/settings.mjs

@@ -0,0 +1,87 @@
+// Settings for dsh-arya-computer-use. Derived from dsh-computer-use-win (MIT),
+// trimmed to the takeover/indicator fields this plugin uses, plus behavior
+// switches for the adapter (headedDefault, overlayDefault, driverLockEnabled).
+
+export const DEFAULT_SETTINGS = Object.freeze({
+  progressOverlayEnabled: true, progressOverlayMode: 'source',
+  progressOverlayOpacity: 60, progressOverlayWidth: 360, progressOverlayHeight: 240, progressOverlayPosition: 'top-right', progressOverlayX: 80, progressOverlayY: 80, progressOverlayLocked: true, progressLockShortcut: '', progressPreviewToken: 0,
+  indicatorEnabled: true, cursorIndicatorEnabled: true, remoteIndicatorVisible: true, indicatorText: 'Arya is controlling your computer', pointerLabel: 'Arya',
+  indicatorPosition: 'top', indicatorIdleMs: 800, stopShortcut: '',
+  resumeToken: 0, previewToken: 0,
+  headedDefault: false, overlayDefault: true, driverLockEnabled: true, toolPreset: 'lite',
+  browserTools: 'core', browserProfile: '', browserSession: '', browserStateFile: '', browserCdp: '', browserHeaded: false,
+});
+
+export const STOP_SHORTCUT_PATTERN = /^(?:(?:Ctrl\+)?(?:Alt\+)?(?:Shift\+)?(?:Win\+)?(?:[A-Z0-9]|F(?:[1-9]|1[0-9]|2[0-4])|Space|Enter|Tab|Backspace|Delete|Insert|Home|End|PageUp|PageDown|Up|Down|Left|Right|Pause|CapsLock|NumLock|ScrollLock))?$/;
+
+export function normalizeStopShortcut(value) {
+  if (typeof value !== 'string') throw new Error('stopShortcut must be a string');
+  if (!value) return '';
+  const parts = value.split('+'), key = parts.pop();
+  const modifiers = ['Ctrl', 'Alt', 'Shift', 'Win'];
+  if (parts.some(part => !modifiers.includes(part)) || new Set(parts).size !== parts.length ||
+      !/^(?:[A-Z0-9]|F(?:[1-9]|1[0-9]|2[0-4])|Space|Enter|Tab|Backspace|Delete|Insert|Home|End|PageUp|PageDown|Up|Down|Left|Right|Pause|CapsLock|NumLock|ScrollLock)$/.test(key)) {
+    throw new Error('stopShortcut must be a supported key with optional Ctrl, Alt, Shift, Win modifiers; Esc is always reserved');
+  }
+  return [...modifiers.filter(part => parts.includes(part)), key].join('+');
+}
+
+// A saved value this version does not offer (chosen in another version, or
+// edited by hand) must not keep the plugin from loading: DSH refuses the whole
+// entry when one value fails, and every tool then disappears with no visible
+// error (#39). Such choices fall back to their defaults; each change is
+// returned so it can be reported. Values typed on the settings page (shortcut,
+// text, numbers) stay strict, so a mistyped one is still refused when saved.
+const SETTING_CHOICES = { indicatorPosition: ['top', 'bottom'] };
+const SETTING_SWITCHES = ['progressOverlayEnabled', 'indicatorEnabled', 'cursorIndicatorEnabled', 'remoteIndicatorVisible', 'progressOverlayLocked', 'headedDefault', 'overlayDefault', 'driverLockEnabled', 'browserHeaded'];
+SETTING_CHOICES.progressOverlayPosition = ['top-right','top-left','bottom-right','bottom-left','custom'];
+SETTING_CHOICES.progressOverlayMode = ['source','summary'];
+SETTING_CHOICES.browserTools = ['core', 'network', 'state', 'debug', 'tabs', 'react', 'mobile', 'all'];
+SETTING_CHOICES.toolPreset = ['lite', 'lazy'];
+export function repairStaleSettings(input) {
+  if (!input || typeof input !== 'object' || Array.isArray(input)) return { value: input, repaired: [] };
+  const value = { ...input }, repaired = [];
+  const read = key => typeof value[key]?.get === 'function' ? value[key].get() : value[key];
+  const reset = key => { repaired.push(`${key}: ${JSON.stringify(read(key))}`); delete value[key]; };
+  for (const [key, allowed] of Object.entries(SETTING_CHOICES)) if (read(key) != null && !allowed.includes(read(key))) reset(key);
+  for (const key of SETTING_SWITCHES) if (read(key) != null && typeof read(key) !== 'boolean') reset(key);
+  return { value, repaired };
+}
+
+export function normalizeSettings(input = {}) {
+  const value = { ...DEFAULT_SETTINGS, ...Object.fromEntries(Object.entries(input).map(([key,value])=>[key,typeof value?.get === 'function' ? value.get() : value])) };
+  for (const key of SETTING_SWITCHES) {
+    if (typeof value[key] !== 'boolean') throw new Error(`${key} must be boolean`);
+  }
+  if (typeof value.indicatorText !== 'string' || !value.indicatorText.trim() || value.indicatorText.length > 120 || /[\r\n\x00-\x1f]/.test(value.indicatorText)) {
+    throw new Error('indicatorText must be one line of 1–120 characters');
+  }
+  if (typeof value.pointerLabel !== 'string' || !value.pointerLabel.trim() || value.pointerLabel.trim().length > 16 || /[\r\n\x00-\x1f]/.test(value.pointerLabel)) {
+    throw new Error('pointerLabel must be one line of 1–16 characters');
+  }
+  value.pointerLabel = value.pointerLabel.trim();
+  if (!['top', 'bottom'].includes(value.indicatorPosition)) throw new Error('indicatorPosition must be top or bottom');
+  if (!Number.isInteger(value.indicatorIdleMs) || value.indicatorIdleMs < 200 || value.indicatorIdleMs > 3000) throw new Error('indicatorIdleMs must be 200–3000');
+  value.stopShortcut = normalizeStopShortcut(value.stopShortcut);
+  value.progressLockShortcut = normalizeStopShortcut(value.progressLockShortcut);
+  if (value.progressLockShortcut && value.progressLockShortcut === value.stopShortcut) throw new Error('progressLockShortcut must differ from the stop shortcut');
+  for (const [key,min,max] of [['progressOverlayOpacity',20,100],['progressOverlayWidth',240,1600],['progressOverlayHeight',160,1600],['progressOverlayX',-32768,32767],['progressOverlayY',-32768,32767]]) {
+    if (!Number.isInteger(value[key]) || value[key] < min || value[key] > max) throw new Error(`${key} must be an integer between ${min} and ${max}`);
+  }
+  if (!SETTING_CHOICES.progressOverlayPosition.includes(value.progressOverlayPosition)) throw new Error('Invalid progressOverlayPosition');
+  if (!SETTING_CHOICES.progressOverlayMode.includes(value.progressOverlayMode)) throw new Error('Invalid progressOverlayMode');
+  if (!SETTING_CHOICES.toolPreset.includes(value.toolPreset)) throw new Error('toolPreset must be one of ' + SETTING_CHOICES.toolPreset.join(', '));
+  if (!SETTING_CHOICES.browserTools.includes(value.browserTools)) throw new Error('browserTools must be one of ' + SETTING_CHOICES.browserTools.join(', '));
+  for (const key of ['browserProfile', 'browserSession', 'browserStateFile', 'browserCdp']) {
+    if (typeof value[key] !== 'string') throw new Error(`${key} must be a string`);
+    if (/[\r\n\x00-\x1f]/.test(value[key])) throw new Error(`${key} must be one line`);
+    value[key] = value[key].trim();
+  }
+  if (value.browserSession && !/^[\p{L}\p{N}_-]+$/u.test(value.browserSession)) throw new Error('browserSession may contain letters, numbers, hyphens and underscores');
+  if (value.browserCdp && !/^(?:\d{1,5}|https?:\/\/\S+|wss?:\/\/\S+)$/.test(value.browserCdp)) throw new Error('browserCdp must be a port, an http(s):// URL or a ws:// URL');
+  if (value.browserStateFile && !/^(?:[A-Za-z]:[\\/]|\/)/.test(value.browserStateFile)) throw new Error('browserStateFile must be an absolute path');
+  for (const key of ['resumeToken', 'previewToken', 'progressPreviewToken']) {
+    if (!Number.isSafeInteger(value[key]) || value[key] < 0) throw new Error(`${key} must be a nonnegative integer`);
+  }
+  return Object.fromEntries(Object.keys(DEFAULT_SETTINGS).map(key => [key, value[key]]));
+}

package/mcp/takeover.mjs

@@ -0,0 +1,253 @@
+import { spawn } from 'node:child_process';
+import { randomUUID } from 'node:crypto';
+import { readFileSync, writeFileSync, mkdirSync, renameSync, unlinkSync } from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { DEFAULT_SETTINGS, normalizeSettings } from './settings.mjs';
+
+export const STOPPED = 'COMPUTER_USE_STOPPED_BY_USER: The user stopped this operation series with Esc or their custom shortcut. Do not retry desktop input in this turn. A new user turn, including a request to continue, can use the desktop automatically; no settings change is required.';
+const helperScript = fileURLToPath(new URL('../scripts/windows-takeover.ps1', import.meta.url));
+// What "Open overlay to adjust" shows: the same layout as a real run.
+export const PREVIEW_PROGRESS = Object.freeze({ step: 2, status: 'acting', tool: 'scroll', action: 'scroll the page', steps: [
+  { step: 1, actions: [{ label: 'open a new tab', state: 'done' }], reasoning: 'This is where DSH streams its thinking text, matching what you see in the chat.', reply: '' },
+  { step: 2, actions: [{ label: 'scroll the page', state: 'running' }], reasoning: 'Long pages can be scrolled; once at the bottom it keeps following new output.', reply: '' }] });
+
+// Windows refuses to replace a file that another process holds open without
+// delete sharing (a reader, an antivirus scan) for a moment, with EPERM, EACCES
+// or EBUSY. Retry the replace briefly, as graceful-fs does for rename on win32.
+const BUSY_CODES = new Set(['EPERM', 'EACCES', 'EBUSY']);
+function pause(ms) {
+  try { Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms); }
+  catch { const end = Date.now() + ms; while (Date.now() < end) { } }
+}
+function replaceFile(from, to) {
+  for (let delay = 10, waited = 0; ; delay = Math.min(delay * 2, 100)) {
+    try { renameSync(from, to); return; }
+    catch (error) {
+      if (!BUSY_CODES.has(error?.code) || waited >= 1000) throw error;
+      pause(delay); waited += delay;
+    }
+  }
+}
+
+export function atomicJson(file, value) {
+  if (!file) return;
+  mkdirSync(path.dirname(file), { recursive: true });
+  const temporary = `${file}.${process.pid}.${randomUUID()}.tmp`;
+  try {
+    writeFileSync(temporary, JSON.stringify(value) + '\n', 'utf8');
+    replaceFile(temporary, file);
+  } catch (error) {
+    // This temporary file belongs to this failed write and has no further use.
+    try { unlinkSync(temporary); } catch { }
+    throw error;
+  }
+}
+
+export class TakeoverControl {
+  constructor({ powershell = 'powershell.exe', onStop = () => {}, configFile = process.env.ARYA_CONFIG_FILE,
+    stateFile = process.env.ARYA_STATE_FILE, activityFile=process.env.ARYA_ACTIVITY_FILE,targetFile=process.env.ARYA_TARGET_FILE,testMode = false, config = {} } = {}) {
+    this.powershell = powershell; this.onStop = onStop; this.configFile = configFile; this.stateFile = stateFile;
+    this.testMode = testMode; this.config = normalizeSettings(config); this.active = 0; this.shown = 0; this.paused = false;
+    this.layoutFile=process.env.ARYA_LAYOUT_FILE;
+    this.targetFile=targetFile;
+    this.progressPreviewToken=this.config.progressPreviewToken;
+    this.activityFile=activityFile;this.seriesHeld=false;this.seriesIndicator=false;this.seriesKey=null;this.stoppedSeriesKey=null;this.blockedSeries=new Map();
+    this.eventName = `Local\\DSH-ARYA-${randomUUID()}`; this.waiters = new Map(); this.nextId = 0;
+    this.resumeToken = this.config.resumeToken; this.previewToken = this.config.previewToken; this.pauseMessage = STOPPED;
+    this.disabledForTest = process.env.NODE_ENV === 'test' && process.env.ARYA_TEST_NO_TAKEOVER === '1';
+    try {
+      const saved = JSON.parse(readFileSync(this.stateFile, 'utf8'));
+      this.paused = saved.paused === true;
+      this.pauseMessage = saved.pauseMessage ?? STOPPED;
+      this.resumeToken = saved.resumeToken ?? this.resumeToken;
+      this.stoppedSeriesKey=saved.stoppedSeriesKey??null;
+      this.blockedSeries=new Map(Object.entries(saved.blockedSeries??(this.stoppedSeriesKey?{[this.stoppedSeriesKey]:this.pauseMessage}:{})));
+    } catch (error) { if (this.stateFile && error.code !== 'ENOENT') throw error; }
+    if (configFile||activityFile) {
+      this.poll = setInterval(() => { this.sync().catch(error => this.fail(error)); }, 250);
+      this.poll.unref();
+    }
+  }
+  persist(reason) {
+    atomicJson(this.stateFile, { paused: this.paused, active: this.active, seriesActive:this.seriesHeld,reason: reason ?? null,
+      resumeToken: this.resumeToken,stoppedSeriesKey:this.stoppedSeriesKey,blockedSeries:Object.fromEntries(this.blockedSeries),pauseMessage: this.paused ? this.pauseMessage : null, updatedAt: new Date().toISOString() });
+  }
+  // What the overlay should frame: the app window being driven, and where the
+  // harness acted (its ghost cursor). Written by the MCP adapter after each call.
+  readTarget() {
+    let raw = null;
+    try { raw = JSON.parse(readFileSync(this.targetFile, 'utf8')); } catch { raw = null; }
+    const window = raw?.window, pointer = raw?.pointer;
+    const rect = window && Number.isFinite(window.width) && Number.isFinite(window.height) && window.width > 0 && window.height > 0
+      ? { left: Math.round(window.left), top: Math.round(window.top), width: Math.round(window.width), height: Math.round(window.height) }
+      : null;
+    const point = pointer && Number.isFinite(pointer.x) && Number.isFinite(pointer.y)
+      ? { x: Math.round(pointer.x), y: Math.round(pointer.y) }
+      : null;
+    return { target: rect, pointer: point };
+  }
+  async resumeOperation(clearScope=true){
+    if(this.child)await this.command('resume');
+    this.paused=false;if(clearScope)this.stoppedSeriesKey=null;
+    this.persist('new-operation');
+  }
+  sync() {
+    // Each caller needs a read after its own config/turn update. Reusing an
+    // in-flight read can otherwise apply the previous turn's stopped state.
+    const pending=(this.syncing??Promise.resolve()).catch(()=>{}).then(()=>this.syncInner());
+    this.syncing=pending;
+    return pending.finally(()=>{if(this.syncing===pending)this.syncing=null;});
+  }
+  async syncInner() {
+    if (this.closed) return;
+    // One synchronous read each: an async read keeps the file open across
+    // event-loop turns, and a writer in the same process (tests run the host's
+    // publisher here) retrying its replace synchronously would wait it out.
+    if (this.configFile) this.config = normalizeSettings(JSON.parse(readFileSync(this.configFile, 'utf8')));
+    if(this.activityFile){
+      const activity=JSON.parse(readFileSync(this.activityFile,'utf8'));
+      const held=activity.active===true&&Number.isFinite(activity.expiresAt)&&activity.expiresAt>Date.now();
+      const key=held?JSON.stringify([activity.sessionId,activity.turn]):this.seriesKey;
+      // A series of browser-lane calls is held for turn tracking but shows
+      // nothing; the indicator starts with the series' first desktop call.
+      const indicator=held&&activity.indicator!==false;
+      // After the turn ends the overlay keeps showing its final state for a
+      // short time; that holds no series, indicator or stop key.
+      const lingering=!held&&!!activity.progress&&Number.isFinite(activity.lingerUntil)&&activity.lingerUntil>Date.now();
+      const progress=JSON.stringify({enabled:this.config.progressOverlayEnabled&&(held||lingering),remoteIndicatorVisible:this.config.remoteIndicatorVisible,settings:this.config,progress:{...activity.progress,status:this.paused&&held?'stopped':activity.progress?.status??'waiting'}});
+      if(!this.disabledForTest&&this.sentProgress!==progress&&(this.child||(this.config.progressOverlayEnabled&&(held||lingering)))){
+        await this.command('progress',JSON.parse(progress));this.sentProgress=progress;
+      }
+      if(held&&!this.blockedSeries.has(key)&&this.paused&&this.active===0)await this.resumeOperation();
+      if(held!==this.seriesHeld||key!==this.seriesKey||indicator!==this.seriesIndicator){
+        this.seriesKey=key;
+        this.seriesHeld=held;this.seriesIndicator=indicator;
+        if(!this.paused&&!this.blockedSeries.has(key)&&!this.disabledForTest){
+          if(indicator)await this.command('begin',this.config);
+          else if(this.shown===0&&this.child)await this.command('end');
+        }
+        this.persist();
+      }
+    }
+    const presentation=JSON.stringify([this.config.indicatorEnabled,this.config.cursorIndicatorEnabled,this.config.remoteIndicatorVisible,this.config.indicatorText,this.config.pointerLabel,this.config.indicatorPosition,this.config.indicatorIdleMs,this.config.stopShortcut]);
+    if (this.child && this.sentPresentation!==presentation) {
+      await this.command(((this.seriesHeld&&this.seriesIndicator)||this.shown>0)&&!this.paused&&!this.blockedSeries.has(this.seriesKey)?'begin':'configure', this.config);
+      this.sentPresentation=presentation;
+      this.sentShortcut = this.config.stopShortcut; this.sentCursorIndicator = this.config.cursorIndicatorEnabled;this.sentRemoteVisible=this.config.remoteIndicatorVisible;
+      // A new overlay host paints nothing until it is told where to look.
+      this.sentTarget=null;
+    }
+    if (this.targetFile && this.child) {
+      const hint=this.readTarget();
+      if(hint!==this.sentTarget){await this.command('hint',hint);this.sentTarget=hint;}
+    }
+    if (this.config.resumeToken !== this.resumeToken && this.active === 0) {
+      if (this.child) await this.command('resume');
+      this.resumeToken = this.config.resumeToken; this.paused = false;this.stoppedSeriesKey=null;this.blockedSeries.clear(); this.persist('resumed-by-user');
+      if(this.seriesHeld&&this.seriesIndicator&&!this.disabledForTest)await this.command('begin',this.config);
+    }
+    if (this.config.previewToken !== this.previewToken) {
+      this.previewToken = this.config.previewToken;
+      if(this.paused&&this.active===0&&!this.seriesHeld)await this.resumeOperation(false);
+      if (!this.paused && this.active === 0 && !this.disabledForTest) await this.command('preview', this.config);
+    }
+    if(this.config.progressPreviewToken!==this.progressPreviewToken){
+      this.progressPreviewToken=this.config.progressPreviewToken;
+      if(!this.disabledForTest&&this.progressPreviewToken>0)await this.command('progress',{enabled:true,preview:true,settings:this.config,remoteIndicatorVisible:this.config.remoteIndicatorVisible,progress:PREVIEW_PROGRESS});
+    }
+  }
+  // A quiet lease (browser-lane calls) checks the stopped state and counts as an
+  // action in progress, but neither shows the indicator nor arms the stop keys.
+  async begin({ quiet = false } = {}) {
+    await this.sync();
+    if(this.seriesHeld&&this.blockedSeries.has(this.seriesKey))throw new Error(this.blockedSeries.get(this.seriesKey));
+    if(this.paused&&!this.activityFile&&this.active===0)await this.resumeOperation();
+    if (this.paused) throw new Error(this.pauseMessage);
+    if (this.closed) throw new Error('COMPUTER_USE_STOPPING');
+    if (!quiet&&!this.disabledForTest&&(!this.seriesHeld||!this.seriesIndicator||!this.child)) {
+      try { await this.command('begin', this.config); this.sentShortcut = this.config.stopShortcut; this.sentCursorIndicator = this.config.cursorIndicatorEnabled;this.sentRemoteVisible=this.config.remoteIndicatorVisible; }
+      catch (error) { this.fail(error); throw error; }
+    }
+    if (this.paused) throw new Error(this.pauseMessage);
+    this.active++; if (!quiet) this.shown++; this.persist();
+  }
+  async end({ quiet = false } = {}) {
+    this.active = Math.max(0, this.active - 1); if (!quiet) this.shown = Math.max(0, this.shown - 1); this.persist(this.paused ? 'stopped-by-user' : null);
+    if (!quiet && this.shown === 0 && !(this.seriesHeld&&this.seriesIndicator)&&this.child && !this.paused) await this.command('end').catch(error => this.fail(error));
+  }
+  fail(error) {
+    if (this.closed || this.paused) return;
+    this.paused = true;
+    this.stoppedSeriesKey=this.seriesKey;
+    this.pauseMessage = error?.message === STOPPED ? STOPPED : `COMPUTER_USE_PAUSED: ${error?.message ?? error}. This operation series is paused. Do not retry in this turn; a new user turn can retry the desktop connection.`;
+    if(this.seriesKey!==null)this.blockedSeries.set(this.seriesKey,this.pauseMessage);
+    this.persist(String(error?.message ?? error));
+    // This also covers a control-file or presentation failure while input runs.
+    this.child?.stdin.write(JSON.stringify({command:'stop'})+'\n',()=>{});
+    this.onStop(new Error(this.pauseMessage));
+  }
+  async start() {
+    if (this.starting) return this.starting;
+    if (this.child) return;
+    this.starting = new Promise((resolve, reject) => {
+      let buffer = '', diagnostic = '', ready = false;
+      const args = ['-NoLogo', '-NoProfile', '-NonInteractive', '-STA', '-ExecutionPolicy', 'Bypass', '-File', helperScript, '-CancelEvent', this.eventName];
+      if (this.testMode) args.push('-TestMode');
+      const child = this.child = spawn(this.powershell, args, { stdio: ['pipe', 'pipe', 'pipe'], windowsHide: true });
+      const deadline = setTimeout(() => { reject(new Error('Takeover stop listener startup timed out')); child.kill(); }, 15000);
+      child.stdout.setEncoding('utf8'); child.stderr.setEncoding('utf8');
+      child.stderr.on('data', chunk => { diagnostic = (diagnostic + chunk).slice(-6000); });
+      child.stdout.on('data', chunk => {
+        buffer += chunk;
+        for (;;) {
+          const at = buffer.indexOf('\n'); if (at < 0) break;
+          const line = buffer.slice(0, at).trim(); buffer = buffer.slice(at + 1); if (!line) continue;
+          let message; try { message = JSON.parse(line); } catch { continue; }
+          if (message.kind === 'ready') { ready = true; clearTimeout(deadline); resolve(); }
+          else if (message.kind === 'stopped') this.fail(new Error(STOPPED));
+          else if (message.kind === 'progress-layout') {
+            if(this.layoutFile)try{atomicJson(this.layoutFile,{id:randomUUID(),patch:message.patch,base:message.base});}catch(error){process.stderr.write('Overlay settings sync failed: '+error.message+'\n');}
+          }
+          else {
+            const pending = this.waiters.get(message.id); if (!pending) continue;
+            clearTimeout(pending.timer); this.waiters.delete(message.id);
+            message.ok ? pending.resolve(message) : pending.reject(new Error(message.error));
+          }
+        }
+      });
+      const died = error => {
+        clearTimeout(deadline);
+        if (this.child === child) this.child = null;
+        const failure = error ?? new Error(`Takeover stop listener exited${diagnostic ? ': ' + diagnostic : ''}`);
+        if (!ready) reject(failure);
+        for (const [id, pending] of this.waiters) { clearTimeout(pending.timer); pending.reject(failure); this.waiters.delete(id); }
+        if (!this.closed) this.fail(failure);
+      };
+      child.once('error', died); child.once('exit', () => died());
+      child.stdin.on('error', () => {});
+    }).finally(() => { this.starting = null; });
+    return this.starting;
+  }
+  async command(command, params = {}) {
+    if(this.closed&&command!=='close')throw Error('COMPUTER_USE_STOPPING');
+    await this.start();
+    const id = ++this.nextId;
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => { this.waiters.delete(id); reject(new Error(`Takeover ${command} timed out`)); }, 5000);
+      this.waiters.set(id, { resolve, reject, timer });
+      this.child.stdin.write(JSON.stringify({ ...params, id, command }) + '\n', error => {
+        if (error) { clearTimeout(timer); this.waiters.delete(id); reject(error); }
+      });
+    });
+  }
+  async close() {
+    this.closed = true; clearInterval(this.poll);
+    if (this.child) {
+      const child = this.child;
+      await this.command('close').catch(() => {});
+      child.stdin.end();
+      const force = setTimeout(() => { if (child.exitCode === null) child.kill(); }, 1000); force.unref();
+    }
+  }
+}

package/package.json

@@ -1,6 +1,90 @@
 {
   "name": "@aryacode/dsh-plugin-arya-computer-use",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "1.0.1",
+  "description": "Computer use for DSH/AryaCode: agent-desktop UIA engine, agent-browser web lane, takeover UI with a ghost cursor",
+  "license": "MIT",
+  "type": "module",
+  "exports": {
+    ".": "./index.js",
+    "./client": "./client.js",
+    "./mcp/adapter-server.mjs": "./mcp/adapter-server.mjs",
+    "./mcp/settings.mjs": "./mcp/settings.mjs",
+    "./mcp/takeover.mjs": "./mcp/takeover.mjs",
+    "./mcp/activity.mjs": "./mcp/activity.mjs",
+    "./locale/*.json": "./locale/*.json",
+    "./icon": "./icon.svg"
+  },
+  "bin": {
+    "arya-computer-use-mcp": "./mcp/adapter-server.mjs"
+  },
+  "files": [
+    "index.js",
+    "client.js",
+    "cordis.patch.yml",
+    "mcp/adapter-server.mjs",
+    "mcp/settings.mjs",
+    "mcp/takeover.mjs",
+    "mcp/activity.mjs",
+    "mcp/browser-launcher.mjs",
+    "scripts/windows-takeover.ps1",
+    "scripts/windows-takeover.cs",
+    "scripts/ocr.ps1",
+    "skills/arya-desktop/SKILL.md",
+    "locale/en.json",
+    "icon.svg",
+    "LICENSE",
+    "NOTICE.md",
+    "docs/PLAN.md"
+  ],
+  "engines": {
+    "node": ">=18",
+    "dsh": ">=0.2.1-rc.3 <0.3.0-0"
+  },
+  "dependencies": {
+    "@deepseek-ai/schemastery": "^3.19.0",
+    "agent-browser": "0.41.2",
+    "agent-desktop": "1.2.0"
+  },
+  "peerDependencies": {
+    "@deepseek-ai/dsh-mcp-client": ">=0.1.0-rc.2 || >=0.2.0-rc.2"
+  },
+  "peerDependenciesMeta": {
+    "@deepseek-ai/dsh-mcp-client": {
+      "optional": true
+    }
+  },
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    },
+    "client": {
+      "platform": "web",
+      "inject": [
+        "@deepseek-ai/dsh-client-locale",
+        "@deepseek-ai/dsh-client-ui-settings"
+      ]
+    }
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/KonnectSuite/dsh-arya-computer-use.git"
+  },
+  "homepage": "https://github.com/KonnectSuite/dsh-arya-computer-use#readme",
+  "bugs": {
+    "url": "https://github.com/KonnectSuite/dsh-arya-computer-use/issues"
+  },
+  "keywords": [
+    "dsh",
+    "dsh-plugin",
+    "computer-use",
+    "agent-desktop",
+    "uia",
+    "accessibility",
+    "agent-browser",
+    "windows"
+  ],
+  "author": "AryaCode",
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/scripts/ocr.ps1

@@ -0,0 +1,95 @@
+<#
+  Arya Computer Use — OCR helper.
+
+  Reads text from a PNG via the WinRT Windows.Media.Ocr engine (the same
+  engine family wincu uses). Run as a standalone powershell.exe process:
+  FullLanguage, outside the DSH pwsh sandbox.
+
+  Output: one JSON object on stdout:
+    { ok, engine, width, height, lines: [ { text, x, y, width, height,
+      words: [ { text, x, y, width, height } ] } ] }
+  Coordinates are PNG pixels (screenshot pixels), not UIA refs.
+#>
+param(
+    [Parameter(Mandatory = $true)][string]$ImagePath
+)
+$ErrorActionPreference = 'Stop'
+[Console]::OutputEncoding = [System.Text.Encoding]::UTF8
+
+# Load the WinRT activation types.
+$null = [Windows.Storage.StorageFile, Windows.Storage, ContentType = WindowsRuntime]
+$null = [Windows.Storage.FileAccessMode, Windows.Storage, ContentType = WindowsRuntime]
+$null = [Windows.Storage.Streams.IRandomAccessStream, Windows.Storage.Streams, ContentType = WindowsRuntime]
+$null = [Windows.Graphics.Imaging.BitmapDecoder, Windows.Graphics.Imaging, ContentType = WindowsRuntime]
+$null = [Windows.Graphics.Imaging.SoftwareBitmap, Windows.Graphics.Imaging, ContentType = WindowsRuntime]
+$null = [Windows.Media.Ocr.OcrEngine, Windows.Media.Ocr, ContentType = WindowsRuntime]
+$null = [Windows.Media.Ocr.OcrResult, Windows.Media.Ocr, ContentType = WindowsRuntime]
+
+# WinRT async bridge: IAsyncOperation<T> arrives as a raw __ComObject (no
+# instance AsTask, reflection can't see its interfaces), so pass the result
+# type explicitly and invoke the generic static AsTask extension — the
+# canonical WinRT-from-PowerShell pattern. Requires FullLanguage powershell.exe
+# (the adapter spawns it directly, outside the DSH pwsh sandbox).
+Add-Type -AssemblyName System.Runtime.WindowsRuntime
+$asTaskGeneric = [System.WindowsRuntimeSystemExtensions].GetMethods() |
+    Where-Object { $_.Name -eq 'AsTask' -and $_.IsGenericMethod -and $_.GetParameters().Count -eq 1 } |
+    Select-Object -First 1
+
+function Await($op, $resultType) {
+    $task = $asTaskGeneric.MakeGenericMethod($resultType).Invoke($null, @($op))
+    $null = $task.Wait(-1)
+    return $task.Result
+}
+
+function EmitJson($obj) {
+    [Console]::Out.WriteLine((ConvertTo-Json -InputObject $obj -Depth 6 -Compress))
+}
+
+if (-not (Test-Path -LiteralPath $ImagePath)) {
+    EmitJson @{ ok = $false; error = "image not found: $ImagePath" }
+    exit 1
+}
+
+$engine = [Windows.Media.Ocr.OcrEngine]::TryCreateFromUserProfileLanguages()
+if (-not $engine) {
+    EmitJson @{ ok = $false; error = 'no OCR engine for user profile languages' }
+    exit 1
+}
+
+$file = Await ([Windows.Storage.StorageFile]::GetFileFromPathAsync($ImagePath)) ([Windows.Storage.StorageFile])
+$stream = Await ($file.OpenAsync([Windows.Storage.FileAccessMode]::Read)) ([Windows.Storage.Streams.IRandomAccessStream])
+$decoder = Await ([Windows.Graphics.Imaging.BitmapDecoder]::CreateAsync($stream)) ([Windows.Graphics.Imaging.BitmapDecoder])
+$bitmap = Await ($decoder.GetSoftwareBitmapAsync()) ([Windows.Graphics.Imaging.SoftwareBitmap])
+$result = Await ($engine.RecognizeAsync($bitmap)) ([Windows.Media.Ocr.OcrResult])
+
+$lines = @()
+foreach ($line in $result.Lines) {
+    $words = @()
+    foreach ($word in $line.Words) {
+        $r = $word.BoundingRect
+        $words += @{
+            text   = $word.Text
+            x      = [math]::Round($r.X)
+            y      = [math]::Round($r.Y)
+            width  = [math]::Round($r.Width)
+            height = [math]::Round($r.Height)
+        }
+    }
+    $lb = $line.BoundingRect
+    $lines += @{
+        text   = $line.Text
+        x      = [math]::Round($lb.X)
+        y      = [math]::Round($lb.Y)
+        width  = [math]::Round($lb.Width)
+        height = [math]::Round($lb.Height)
+        words  = $words
+    }
+}
+
+EmitJson @{
+    ok     = $true
+    engine = $engine.RecognizerLanguage.LanguageTag
+    width  = $bitmap.PixelWidth
+    height = $bitmap.PixelHeight
+    lines  = $lines
+}