@aglit-ai/cli 0.0.0-stage → 0.1.1

package/README.md

@@ -1,3 +1,69 @@
-# Temporary Holding Version
+# Aglit Computer Use
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Computer Use makes a signed-in desktop remotely controllable from the user's Aglit
+account. Aglit Mini Computer remains the separate VM host application.
+
+After the CLI and a compatible signed desktop release have been published:
+
+```sh
+pnpm add -g @aglit-ai/cli
+aglit install
+aglit init
+aglit status
+aglit disable
+aglit enable
+aglit uninstall
+```
+
+`init` opens Aglit's Google login in the browser, asks for a computer name,
+detects existing Codex/Claude logins, and uses a configured authenticated provider
+or the sole available provider. Multiple usable providers prompt for a choice.
+Provider login detection is not an inference acceptance check. Original provider
+accounts remain owned by the user; uninstall does not delete their original login.
+
+```sh
+aglit init --name "Office Mac" --provider codex
+aglit providers
+aglit teams
+aglit init --name "Office Mac" --provider auto --team TEAM_ID
+aglit invite USER_EMAIL --team TEAM_ID
+```
+
+For unattended setup, provide `--name` and an explicit `--provider` when detection
+cannot select a single provider. Initial account login and OS consent still need
+the user. On macOS, Screen Recording and Accessibility must be granted before
+`init` enables access. The native tray offers status, enable/disable, Console and
+quit while the application shell stays hidden. Login-item registration starts
+the same private profile on the next user login.
+
+`--team` selects the existing backend team/invitation scope. It does not grant team
+members access to a separately registered personal computer. The backend requires
+current accepted membership/admin authority for its operations; a pending
+invitation is not access. Shared computer enrollment needs an authoritative team
+device binding, which this CLI does not create from a caller-supplied team ID.
+
+`status` distinguishes the local enabled setting from a connected tunnel. It also
+reports permissions and the selected provider. Neither status means video/input,
+inference or end-to-end cryptographic acceptance has been verified.
+
+`uninstall` purges by default. It disables this installation, revokes viewer
+sessions, confirms deletion of its cloud registration, removes its login item,
+signs out, waits for its process to exit and deletes its private runtime/profile.
+This includes bundled plugins/helpers, copied provider state, keys, settings,
+history and logs inside that installation. Mini Computer, VMs, shared browser
+profiles, existing provider accounts and other applications are outside that
+ownership. A failed cloud revocation preserves credentials for retry; local
+access is disabled. Interrupted native-file cleanup can be resumed with the same
+command. The package-manager-installed CLI wrapper itself can be removed with
+`pnpm remove -g @aglit-ai/cli` after runtime uninstall.
+
+The installer supports the existing Apple silicon macOS and Windows x64 release
+formats. It verifies the platform pointer against the immutable version receipt,
+asset size and SHA-256/SHA-512, contained archive paths/links, OS publisher admission,
+the exact source commit, obfuscation marker and native CLI protocol version before
+launch. Unsigned Windows artifacts and older desktop releases are rejected.
+Computer Use starts with Anywhere Access disabled and a new per-install device
+identity. It never adopts a managed guest's key or changes its registration.
+
+See [architecture and acceptance](../../docs/computer-use.md). The source CLI can
+be inspected without installation using `node packages/cli/bin/aglit.cjs --help`.

package/bin/aglit.cjs

@@ -0,0 +1,138 @@
+#!/usr/bin/env node
+'use strict';
+const fs = require('node:fs');
+const path = require('node:path');
+const os = require('node:os');
+const { parseArgs } = require('node:util');
+const { createInterface } = require('node:readline/promises');
+const installation = require('../src/installation.cjs');
+const delay = ms => new Promise(resolve => setTimeout(resolve, ms));
+const help = `Aglit Computer Use
+
+  aglit install
+  aglit init [--name "Computer name"] [--provider codex|claude|auto] [--team TEAM_ID] [--invite EMAIL]
+  aglit status [--json]
+  aglit enable | disable
+  aglit teams
+  aglit providers
+  aglit invite EMAIL --team TEAM_ID
+  aglit uninstall
+
+Uninstall revokes remote access and purges this installation, including login,
+settings, owned bundled plugins/helpers and local data. Mini Computer and VMs
+are separate. Team invitations require backend authorization; pending invites
+grant no access. A team selector never grants access to a personal computer.
+`;
+
+async function finishUninstall(receipt) {
+  const deadline = Date.now() + 30000;
+  while (Date.now() < deadline) {
+    await delay(500);
+    try { process.kill(receipt.pid, 0); } catch (error) {
+      if (error.code !== 'ESRCH') throw error;
+      installation.purge();
+      process.stdout.write(JSON.stringify({ uninstalled: true, purged: true }) + '\n'); return;
+    }
+  }
+  throw Error('Runtime has not exited; local files preserved. Retry aglit uninstall after it quits.');
+}
+
+async function main() {
+  const { values, positionals } = parseArgs({ options: { name: { type: 'string' }, provider: { type: 'string' }, team: { type: 'string' }, invite: { type: 'string' }, json: { type: 'boolean' }, help: { type: 'boolean', short: 'h' } }, allowPositionals: true, strict: true });
+  if (values.help || !positionals.length) { process.stdout.write(help); return; }
+  const [command, email] = positionals;
+  const options = { install: [], init: ['name', 'provider', 'team', 'invite'], status: ['json'], enable: [], disable: [], teams: [], providers: [], invite: ['team'], uninstall: [] };
+  if (!Object.hasOwn(options, command) || Object.keys(values).some(key => !options[command].includes(key)) || positionals.length > (command === 'invite' ? 2 : 1)) throw Error('Invalid command or options. Run aglit --help.');
+  if (values.team && !/^[A-Za-z0-9._:-]{1,128}$/.test(values.team)) throw Error('Invalid team ID');
+  if (values.provider && !['auto', 'codex', 'claude'].includes(values.provider)) throw Error('Provider must be auto, codex or claude');
+  const recipient = command === 'invite' ? email : values.invite;
+  if (recipient && (recipient.length > 254 || !/^[^\s@*]+@[^\s@*]+\.[^\s@*]+$/.test(recipient))) throw Error('An individual invitation email address is required');
+  if ((command === 'invite' || values.invite) && (!recipient || !values.team)) throw Error('Invitations require an email address and --team TEAM_ID');
+  if (values.name !== undefined && (!values.name.trim() || values.name.length > 100 || /[\x00-\x1f\x7f]/.test(values.name))) throw Error('Computer name must contain 1–100 printable characters');
+  const print = value => process.stdout.write(JSON.stringify(value, null, 2) + '\n');
+  if (command === 'install') { print(await installation.install()); return; }
+  if (command === 'status' && !fs.existsSync(path.join(installation.root, 'installation.json'))) {
+    print({ product: 'Aglit Computer Use', installed: false, running: false, enabled: false }); return;
+  }
+  if (command === 'uninstall' && !fs.existsSync(path.join(installation.root, 'installation.json'))) {
+    if (fs.existsSync(installation.root)) installation.purgeIncomplete();
+    print({ uninstalled: true, purged: true }); return;
+  }
+  if (command === 'uninstall' || command === 'status') {
+    const pending = installation.readUninstall();
+    if (pending) {
+      if (command === 'uninstall') await finishUninstall(pending);
+      else print({ installed: true, uninstalling: true, enabled: false });
+      return;
+    }
+  }
+  installation.readInstallation();
+  const configPath = path.join(installation.profile, 'ipc/sdk-ipc.json');
+  const control = (action, fields = {}) => require('../src/control.cjs').control(configPath, action, fields);
+  let state;
+  try { state = await control('status'); } catch (error) {
+    if (command === 'status') { print({ installed: true, running: false, enabled: null, error: error.message }); process.exitCode = 1; return; }
+    installation.start();
+    const deadline = Date.now() + 60000;
+    while (Date.now() < deadline) {
+      await delay(1000);
+      try { state = await control('status'); break; } catch { /* Wait for this installed runtime's native socket. */ }
+    }
+    if (!state) throw Error('Computer Use did not become ready. See runtime.log in its installation directory.');
+  }
+  if (command === 'status') { print(state); return; }
+  if (command === 'init') {
+    if (!state.email) {
+      await control('login');
+      process.stderr.write('Complete sign-in in your browser.\n');
+      const deadline = Date.now() + 5 * 60000;
+      while (Date.now() < deadline) {
+        await delay(1500); state = await control('status'); if (state.email) break;
+      }
+      if (!state.email) throw Error('Sign-in timed out. Run aglit init to resume.');
+    }
+    let name = values.name || state.name;
+    if (!name && process.stdin.isTTY) {
+      const prompt = createInterface({ input: process.stdin, output: process.stderr });
+      try { name = (await prompt.question(`Computer name [${os.hostname()}]: `)).trim() || os.hostname(); } finally { prompt.close(); }
+    }
+    if (!name) throw Error('Provide --name for unattended setup');
+    const detected = await control('providers');
+    const available = detected.providers.filter(provider => provider.authenticated).map(provider => provider.provider);
+    let provider = values.provider && values.provider !== 'auto' ? values.provider :
+      available.includes(detected.preferred) ? detected.preferred : available.length === 1 ? available[0] : null;
+    if (!provider && available.length && process.stdin.isTTY) {
+      const prompt = createInterface({ input: process.stdin, output: process.stderr });
+      try { provider = (await prompt.question(`Provider (${available.join(', ')}): `)).trim(); } finally { prompt.close(); }
+    }
+    if (!provider || !available.includes(provider)) throw Error('No provider selected with a usable login. Sign in to Codex or Claude on this computer, then rerun aglit init --provider codex|claude.');
+    await control('configure', { name, provider, ...(values.team ? { teamId: values.team } : {}) });
+    const permissions = await control('permissions');
+    print(permissions);
+    if (permissions.permissions?.supported && (permissions.permissions.screenRecording !== 'granted' || permissions.permissions.accessibility !== 'granted'))
+      throw Error('Grant Screen Recording and Accessibility in System Settings, then rerun aglit init. Anywhere Access has not been enabled.');
+    // An enable receipt is configuration, not proof that capture/input work.
+    await control('enable');
+    const connectionDeadline = Date.now() + 30000;
+    do {
+      state = await control('status');
+      if (state.connected) break;
+      await delay(1000);
+    } while (Date.now() < connectionDeadline);
+    print(state);
+    if (!state.connected) throw Error('Anywhere Access is enabled but its connection is not ready. Check aglit status before retrying.');
+    if (values.invite) print(await control('invite', { teamId: values.team, email: values.invite }));
+    return;
+  }
+  if (command === 'invite') { print(await control('invite', { teamId: values.team, email })); return; }
+  if (command === 'uninstall') {
+    const result = await control('uninstall');
+    if (!result?.revoked || !result?.quitting || !Number.isSafeInteger(result.pid) || result.pid <= 0) throw Error('Revocation was not confirmed; installation preserved');
+    await finishUninstall(result); return;
+  }
+  print(await control(command));
+}
+
+main().then(() => process.exit(process.exitCode || 0), error => {
+  process.stderr.write(`aglit: ${error.message}\n`); process.exit(1);
+});

package/package.json

@@ -1,6 +1,24 @@
 {
   "name": "@aglit-ai/cli",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.1",
+  "description": "Install and manage Aglit Computer Use",
+  "license": "UNLICENSED",
+  "type": "commonjs",
+  "bin": {
+    "aglit": "bin/aglit.cjs"
+  },
+  "files": [
+    "bin",
+    "src",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=22"
+  },
+  "dependencies": {
+    "yauzl": "3.4.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/src/control.cjs

@@ -0,0 +1,55 @@
+'use strict';
+const fs = require('node:fs');
+const net = require('node:net');
+const crypto = require('node:crypto');
+
+// One authenticated request per connection, with no automatic mutation replay.
+// This is the existing native SDK handshake, not a new localhost HTTP API.
+function control(configPath, action, fields = {}) {
+  const stat = fs.lstatSync(configPath);
+  if (!stat.isFile() || stat.isSymbolicLink() || fs.realpathSync(configPath) !== configPath || stat.nlink !== 1 || stat.size > 65536 ||
+      process.platform !== 'win32' && (stat.uid !== process.getuid() || stat.mode & 0o077)) throw Error('Private native control configuration required');
+  const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+  if (config.version !== 1 || typeof config.endpoint !== 'string' || typeof config.token !== 'string' ||
+      !config.token || config.token.length > 4096) throw Error('Native control configuration is incomplete');
+  if (process.platform === 'win32') {
+    if (!config.endpoint.startsWith('\\\\.\\pipe\\aglit-ai-sdk-')) throw Error('Unexpected native pipe');
+  } else {
+    const socket = fs.lstatSync(config.endpoint);
+    if (!socket.isSocket() || socket.uid !== process.getuid()) throw Error('Native socket owner differs');
+  }
+  return new Promise((resolve, reject) => {
+    const id = crypto.randomUUID();
+    const socket = net.createConnection(config.endpoint);
+    let buffer = '', authenticated = false, settled = false;
+    const timeout = setTimeout(() => finish(Error('Native command timed out; its outcome may be uncertain. Check aglit status before retrying.')), action === 'permissions' ? 5 * 60000 : 30000);
+    const finish = (error, result) => {
+      if (settled) return;
+      settled = true; clearTimeout(timeout); socket.destroy();
+      if (error) reject(error); else resolve(result);
+    };
+    socket.setEncoding('utf8');
+    socket.once('connect', () => socket.write(JSON.stringify({ type: 'handshake', token: config.token }) + '\n'));
+    socket.on('error', error => finish(error));
+    socket.once('close', () => { if (!settled) finish(Error('Native connection closed before command acknowledgement')); });
+    socket.on('data', chunk => {
+      buffer += chunk;
+      if (Buffer.byteLength(buffer) > 256 * 1024) return finish(Error('Native response too large'));
+      let newline;
+      while ((newline = buffer.indexOf('\n')) >= 0) {
+        let response;
+        try { response = JSON.parse(buffer.slice(0, newline)); } catch { return finish(Error('Invalid native response')); }
+        buffer = buffer.slice(newline + 1);
+        if (!authenticated) {
+          if (response.type !== 'handshake' || response.ok !== true || response.version !== 1) return finish(Error('Native authentication rejected'));
+          authenticated = true;
+          socket.write(JSON.stringify({ id, request: { method: 'POST', path: '/computer-use/control', body: { action, ...fields } } }) + '\n');
+        } else {
+          if (response.id !== id) return finish(Error('Native response identity differs'));
+          return response.ok === true ? finish(null, response.result) : finish(Error(response.error || 'Native command rejected'));
+        }
+      }
+    });
+  });
+}
+module.exports = { control };

package/src/extract.cjs

@@ -0,0 +1,52 @@
+'use strict';
+const fs = require('node:fs');
+const path = require('node:path');
+const { pipeline } = require('node:stream/promises');
+
+// Extract into a fresh private directory. Defer contained relative symlinks until
+// all regular files have been written, so archive links cannot redirect writes.
+async function extract(archive, root) {
+  const yauzl = require('yauzl');
+  const zip = await new Promise((resolve, reject) => yauzl.open(archive, { lazyEntries: true, strictFileNames: true }, (error, value) => error ? reject(error) : resolve(value)));
+  const links = [];
+  let entries = 0, bytes = 0;
+  try {
+    await new Promise((resolve, reject) => {
+      zip.on('error', reject);
+      zip.on('end', resolve);
+      zip.on('entry', entry => {
+        void (async () => {
+          const name = entry.fileName;
+          if (++entries > 200000 || name.length > 4096 || /[\x00-\x1f\\]/.test(name) || path.isAbsolute(name) || /^[A-Za-z]:/.test(name) || name.split('/').includes('..')) throw Error('Unsafe archive entry');
+          const destination = path.resolve(root, name);
+          if (!destination.startsWith(root + path.sep)) throw Error('Archive entry escapes installation');
+          bytes += entry.uncompressedSize;
+          if (!Number.isSafeInteger(bytes) || bytes > 16 * 1024 ** 3) throw Error('Expanded release exceeds installation limit');
+          const mode = entry.externalFileAttributes >>> 16;
+          if (name.endsWith('/')) { fs.mkdirSync(destination, { recursive: true, mode: 0o755 }); return; }
+          const stream = await new Promise((done, fail) => zip.openReadStream(entry, (error, value) => error ? fail(error) : done(value)));
+          if ((mode & 0o170000) === 0o120000) {
+            if (entry.uncompressedSize > 4096) throw Error('Archive link too large');
+            const chunks = [];
+            for await (const chunk of stream) chunks.push(chunk);
+            const target = new TextDecoder('utf-8', { fatal: true }).decode(Buffer.concat(chunks));
+            const resolved = path.resolve(path.dirname(destination), target);
+            if (!target || /[\x00-\x1f\\]/.test(target) || path.isAbsolute(target) || /^[A-Za-z]:/.test(target) || !resolved.startsWith(root + path.sep)) throw Error('Archive link escapes installation');
+            links.push({ destination, target });
+          } else {
+            if ((mode & 0o170000) && (mode & 0o170000) !== 0o100000) throw Error('Unsupported archive entry');
+            fs.mkdirSync(path.dirname(destination), { recursive: true, mode: 0o755 });
+            await pipeline(stream, fs.createWriteStream(destination, { flags: 'wx', mode: mode & 0o777 || 0o644 }));
+          }
+        })().then(() => zip.readEntry(), reject);
+      });
+      zip.readEntry();
+    });
+    for (const link of links) fs.mkdirSync(path.dirname(link.destination), { recursive: true, mode: 0o755 });
+    for (const link of links) fs.symlinkSync(link.target, link.destination);
+    for (const link of links) {
+      if (!fs.realpathSync(link.destination).startsWith(root + path.sep)) throw Error('Resolved archive link escapes installation');
+    }
+  } finally { zip.close(); }
+}
+module.exports = { extract };

package/src/installation.cjs

@@ -0,0 +1,214 @@
+'use strict';
+const fs = require('node:fs');
+const path = require('node:path');
+const os = require('node:os');
+const crypto = require('node:crypto');
+const { spawn, execFileSync } = require('node:child_process');
+const { pipeline } = require('node:stream/promises');
+const { Readable, Transform } = require('node:stream');
+
+const root = path.join(process.platform === 'darwin' ? path.join(os.homedir(), 'Library/Application Support') :
+  process.platform === 'win32' ? process.env.APPDATA || path.join(os.homedir(), 'AppData/Roaming') : path.join(os.homedir(), '.config'), 'Aglit Computer Use');
+const profile = path.join(root, 'profile');
+const receiptPath = path.join(root, 'installation.json');
+const same = (a, b) => process.platform === 'win32' ? a.toLowerCase() === b.toLowerCase() : a === b;
+function canonical(file) {
+  if (!path.isAbsolute(file) || !same(fs.realpathSync(file), file) || fs.lstatSync(file).isSymbolicLink()) throw Error('Canonical installation path required');
+}
+function run(program, args, options = {}) {
+  return execFileSync(program, args, { windowsHide: true, timeout: 60000, maxBuffer: 1024 * 1024, encoding: 'utf8', ...options });
+}
+const powershell = path.join(process.env.SystemRoot || 'C:\\Windows', 'System32/WindowsPowerShell/v1.0/powershell.exe');
+function privateRoot(create = false) {
+  canonical(root);
+  if (process.platform !== 'win32') {
+    const stat = fs.statSync(root);
+    if (stat.uid !== process.getuid() || stat.mode & 0o077) throw Error('Private installation owner required');
+    return;
+  }
+  const script = String.raw`
+$ErrorActionPreference='Stop'
+$target=$env:AGLIT_PRIVATE_ROOT;$sid=[Security.Principal.WindowsIdentity]::GetCurrent().User
+$system=[Security.Principal.SecurityIdentifier]::new('S-1-5-18')
+if($env:AGLIT_CREATE_PRIVATE_ROOT -eq '1'){
+ $acl=[Security.AccessControl.DirectorySecurity]::new();$acl.SetOwner($sid);$acl.SetAccessRuleProtection($true,$false)
+ foreach($identity in @($sid,$system)){$acl.AddAccessRule([Security.AccessControl.FileSystemAccessRule]::new($identity,'FullControl','ContainerInherit,ObjectInherit','None','Allow'))}
+ Set-Acl -LiteralPath $target -AclObject $acl
+}
+$acl=Get-Acl -LiteralPath $target
+if(!$acl.AreAccessRulesProtected -or $acl.GetOwner([Security.Principal.SecurityIdentifier]).Value -ne $sid.Value){throw 'Private installation owner required'}
+foreach($rule in $acl.GetAccessRules($true,$true,[Security.Principal.SecurityIdentifier])){
+ if($rule.AccessControlType -ne 'Allow' -or $rule.IdentityReference.Value -notin @($sid.Value,$system.Value)){throw 'Private installation ACL required'}
+}
+`;
+  run(powershell, ['-NoLogo', '-NoProfile', '-NonInteractive', '-WindowStyle', 'Hidden', '-Command', script], {
+    env: { ...process.env, AGLIT_PRIVATE_ROOT: root, AGLIT_CREATE_PRIVATE_ROOT: create ? '1' : '0' },
+  });
+}
+function readInstallation(allowPartialCleanup = false) {
+  privateRoot();
+  canonical(receiptPath);
+  if (fs.statSync(receiptPath).size > 65536) throw Error('Installation receipt too large');
+  const value = JSON.parse(fs.readFileSync(receiptPath, 'utf8'));
+  if (value.kind !== 'aglit-computer-use-installation-v1' || value.root !== root ||
+      value.profile !== profile || typeof value.executable !== 'string' ||
+      !value.executable.startsWith(root + path.sep) || !/^[a-f0-9]{64}$/.test(value.sha256)) throw Error('Installation receipt differs');
+  if (!allowPartialCleanup) { canonical(value.executable); canonical(value.profile); }
+  return value;
+}
+async function download(url) {
+  for (let hop = 0; hop < 6; hop++) {
+    const target = new URL(url);
+    if (target.protocol !== 'https:' || !['github.com', 'release-assets.githubusercontent.com', 'objects.githubusercontent.com'].includes(target.hostname)) throw Error('Untrusted release URL');
+    const response = await fetch(target, { redirect: 'manual', signal: AbortSignal.timeout(30 * 60 * 1000) });
+    if ([301, 302, 303, 307, 308].includes(response.status)) {
+      await response.body?.cancel();
+      url = new URL(response.headers.get('location'), target).href;
+      continue;
+    }
+    if (!response.ok || !response.body) throw Error(`Release download failed (${response.status})`);
+    return response;
+  }
+  throw Error('Too many release redirects');
+}
+async function json(url) {
+  const response = await download(url);
+  let size = 0;
+  const chunks = [];
+  for await (const chunk of response.body) {
+    size += chunk.length;
+    if (size > 65536) throw Error('Release metadata too large');
+    chunks.push(chunk);
+  }
+  return JSON.parse(Buffer.concat(chunks).toString('utf8'));
+}
+function parseRelease(value, platform) {
+  const fields = ['kind', 'package', 'platform', 'version', 'sourceCommit', 'assets', 'windowsSigningPolicy'];
+  if (!value || Object.keys(value).some(key => !fields.includes(key)) || value.kind !== 'aglit-github-release-v1' ||
+      value.package !== 'desktop-app' || value.platform !== platform || !/^\d+\.\d+\.\d+$/.test(value.version) ||
+      !/^[a-f0-9]{40}$/.test(value.sourceCommit) || !Array.isArray(value.assets) || value.assets.length !== 3 ||
+      value.windowsSigningPolicy !== undefined && (platform !== 'win' || value.windowsSigningPolicy !== 'unsigned-user-accepted')) throw Error('Invalid desktop release receipt');
+  const stem = `Aglit.AI-${value.version}-${platform === 'mac' ? 'mac-arm64' : 'win-x64'}`;
+  const names = platform === 'mac' ? [stem + '.dmg', stem + '.zip', stem + '.zip.blockmap'] : [stem + '.exe', stem + '.exe.blockmap', stem + '.zip'];
+  for (let index = 0; index < 3; index++) {
+    const asset = value.assets[index];
+    if (!asset || Object.keys(asset).sort().join(',') !== 'name,sha256,sha512,size' || asset.name !== names[index] ||
+        !Number.isSafeInteger(asset.size) || asset.size <= 0 || asset.size > 2 * 1024 ** 3 ||
+        !/^[a-f0-9]{64}$/.test(asset.sha256) || !/^[A-Za-z0-9+/]{86}==$/.test(asset.sha512)) throw Error('Invalid release asset');
+  }
+  return value;
+}
+function verifyPublisher(executable) {
+  if (process.platform === 'darwin') {
+    const bundle = path.resolve(executable, '../../..');
+    run('/usr/bin/codesign', ['--verify', '--deep', '--strict', '--test-requirement', '=anchor apple generic and identifier "ai.aglit.desktop" and certificate leaf[subject.OU] = "8DVJD3J343"', bundle]);
+    run('/usr/sbin/spctl', ['--assess', '--type', 'execute', bundle]);
+  } else {
+    const script = '$s=Get-AuthenticodeSignature -LiteralPath $env:AGLIT_VERIFY_EXECUTABLE; if($s.Status -ne "Valid" -or $s.SignerCertificate.Subject -notmatch "(?:^|,\\s*)CN=Aglit AI(?:,|$)"){throw "Aglit publisher signature required"}';
+    run(powershell, ['-NoLogo', '-NoProfile', '-NonInteractive', '-WindowStyle', 'Hidden', '-Command', script], { env: { ...process.env, AGLIT_VERIFY_EXECUTABLE: executable } });
+  }
+}
+async function install() {
+  if (fs.existsSync(path.join(root, 'uninstalling.json'))) throw Error('Finish aglit uninstall before reinstalling');
+  if (!(process.platform === 'darwin' && process.arch === 'arm64') && !(process.platform === 'win32' && process.arch === 'x64')) throw Error('Published Computer Use releases currently support Apple silicon Macs and Windows x64');
+  if (fs.existsSync(receiptPath)) return { installed: true, ...readInstallation() };
+  if (fs.existsSync(root)) throw Error(`Existing unowned installation directory preserved: ${root}`);
+  const platform = process.platform === 'darwin' ? 'mac' : 'win';
+  const base = 'https://github.com/Aglit-AI/desktop-app-release/releases/download/';
+  const desired = parseRelease(await json(base + `updates-${platform}/github-release-${platform}.json`), platform);
+  const release = parseRelease(await json(base + `v${desired.version}/github-release-${platform}.json`), platform);
+  if (JSON.stringify(desired) !== JSON.stringify(release)) throw Error('Release pointer differs from immutable release');
+  // The product's unsigned Windows policy is not silently inherited by the CLI.
+  if (release.windowsSigningPolicy) throw Error('This Windows release is unsigned; Computer Use installation requires a signed release');
+  canonical(path.dirname(root));
+  fs.mkdirSync(root, { mode: 0o700 });
+  privateRoot(true);
+  fs.writeFileSync(path.join(root, 'installation-attempt.json'), JSON.stringify({ kind: 'aglit-computer-use-attempt-v1', root }) + '\n', { flag: 'wx', mode: 0o600 });
+  const asset = release.assets.find(item => item.name.endsWith('.zip'));
+  const archive = path.join(root, 'runtime.zip');
+  let received = 0;
+  const sha256 = crypto.createHash('sha256'), sha512 = crypto.createHash('sha512');
+  const meter = new Transform({ transform(chunk, _encoding, done) {
+    received += chunk.length;
+    if (received > asset.size) return done(Error('Release exceeds declared size'));
+    sha256.update(chunk); sha512.update(chunk); done(null, chunk);
+  } });
+  const response = await download(base + `v${release.version}/${asset.name}`);
+  await pipeline(Readable.fromWeb(response.body), meter, fs.createWriteStream(archive, { flags: 'wx', mode: 0o600 }));
+  if (received !== asset.size || sha256.digest('hex') !== asset.sha256 || sha512.digest('base64') !== asset.sha512) throw Error('Release checksum differs; archive was not executed');
+  const runtime = path.join(root, 'runtime');
+  fs.mkdirSync(runtime, { mode: 0o700 });
+  await require('./extract.cjs').extract(archive, runtime);
+  const executable = process.platform === 'darwin' ? path.join(runtime, 'Aglit AI.app/Contents/MacOS/Aglit AI') : path.join(runtime, 'Aglit AI.exe');
+  canonical(executable);
+  verifyPublisher(executable);
+  const resources = process.platform === 'darwin' ? path.join(runtime, 'Aglit AI.app/Contents/Resources') : path.join(runtime, 'resources');
+  const buildInfoPath = path.join(resources, 'app.asar.unpacked/dist-electron/desktop-app/build-info.json');
+  canonical(buildInfoPath);
+  if (fs.statSync(buildInfoPath).size > 16 * 1024 * 1024) throw Error('Build metadata too large');
+  const buildInfo = JSON.parse(fs.readFileSync(buildInfoPath, 'utf8'));
+  if (buildInfo.gitCommit !== release.sourceCommit || buildInfo.dirty !== false ||
+      buildInfo.runtimeMinified !== true || buildInfo.computerUseControlVersion !== 1)
+    throw Error('A published obfuscated desktop release with Computer Use CLI support is required; this archive was not launched');
+  fs.mkdirSync(profile, { mode: 0o700 });
+  fs.writeFileSync(path.join(profile, 'system-settings.json'), JSON.stringify({ settings: { enableAnywhereAccess: false, remoteAccessDeviceId: crypto.randomUUID() } }) + '\n', { flag: 'wx', mode: 0o600 });
+  const receipt = { kind: 'aglit-computer-use-installation-v1', root, profile, executable, version: release.version, sourceCommit: release.sourceCommit, sha256: asset.sha256 };
+  fs.writeFileSync(receiptPath, JSON.stringify(receipt) + '\n', { flag: 'wx', mode: 0o600 });
+  fs.unlinkSync(archive);
+  return { installed: true, ...receipt };
+}
+function start() {
+  if (fs.existsSync(path.join(root, 'uninstalling.json'))) throw Error('Computer Use is uninstalling. Run aglit uninstall to finish cleanup.');
+  if (process.platform === 'win32') run(powershell, ['-NoLogo', '-NoProfile', '-NonInteractive', '-WindowStyle', 'Hidden', '-Command',
+    '$p=[Security.Principal.WindowsPrincipal]::new([Security.Principal.WindowsIdentity]::GetCurrent()); if($p.IsInRole([Security.Principal.WindowsBuiltInRole]::Administrator)){throw "Run aglit init from a non-elevated interactive user terminal"}']);
+  const installed = readInstallation();
+  verifyPublisher(installed.executable);
+  const log = fs.openSync(path.join(root, 'runtime.log'), 'a', 0o600);
+  const env = { ...process.env };
+  // Do not let an operator's guest/development environment adopt another identity.
+  for (const key of Object.keys(env)) if (key.startsWith('AGLIT_') || key.startsWith('VITE_') || ['NODE_ENV', 'ELECTRON_RUN_AS_NODE', 'SERVER_PORT', 'ELECTRON_BRIDGE_PORT'].includes(key)) delete env[key];
+  Object.assign(env, { AGLIT_USER_DATA_PATH: profile, AGLIT_ELECTRON_USER_DATA_PATH: profile });
+  const child = spawn(installed.executable, ['--computer-use'], { detached: true, windowsHide: true, stdio: ['ignore', log, log], env });
+  child.on('error', error => { process.stderr.write(`Computer Use failed to start: ${error.message}\n`); });
+  child.unref(); fs.closeSync(log);
+}
+function purge() {
+  readInstallation(true);
+  // Exact fixed per-user root only. Node removes contained symlinks themselves;
+  // it does not recursively follow them into Mini Computer or browser profiles.
+  if (path.resolve(root) !== root || path.basename(root) !== 'Aglit Computer Use') throw Error('Purge target differs');
+  canonical(root);
+  // Preserve recovery receipts until all potentially locked native payloads have
+  // been removed. A failed Windows deletion can then resume the same uninstall.
+  for (const name of fs.readdirSync(root)) {
+    if (name === 'installation.json' || name === 'uninstalling.json') continue;
+    const target = path.join(root, name);
+    if (path.dirname(target) !== root) throw Error('Cleanup target escapes installation');
+    fs.rmSync(target, { recursive: true, force: false, maxRetries: 3, retryDelay: 300 });
+  }
+  if (fs.existsSync(path.join(root, 'uninstalling.json'))) fs.unlinkSync(path.join(root, 'uninstalling.json'));
+  fs.unlinkSync(receiptPath);
+  fs.rmdirSync(root);
+  if (fs.existsSync(root)) throw Error('Computer Use cleanup is incomplete');
+}
+function purgeIncomplete() {
+  if (fs.existsSync(receiptPath)) throw Error('Installed Computer Use must revoke access before uninstall');
+  privateRoot();
+  const attempt = path.join(root, 'installation-attempt.json');
+  canonical(attempt);
+  if (fs.statSync(attempt).size > 4096) throw Error('Invalid installation attempt');
+  const receipt = JSON.parse(fs.readFileSync(attempt, 'utf8'));
+  if (receipt.kind !== 'aglit-computer-use-attempt-v1' || receipt.root !== root) throw Error('Unknown installation directory preserved');
+  fs.rmSync(root, { recursive: true, force: false });
+}
+function readUninstall() {
+  const file = path.join(root, 'uninstalling.json');
+  if (!fs.existsSync(file)) return null;
+  readInstallation(true); canonical(file);
+  if (fs.statSync(file).size > 4096) throw Error('Invalid uninstall receipt');
+  const receipt = JSON.parse(fs.readFileSync(file, 'utf8'));
+  if (receipt.kind !== 'aglit-computer-use-uninstall-v1' || receipt.root !== root || receipt.revoked !== true ||
+      !Number.isSafeInteger(receipt.pid) || receipt.pid <= 0) throw Error('Invalid uninstall receipt');
+  return receipt;
+}
+module.exports = { root, profile, readInstallation, install, start, purge, purgeIncomplete, readUninstall };