@aglit-ai/cli 0.0.0-stage → 0.1.2

package/README.md

@@ -1,3 +1,89 @@
-# 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
+aglit start --headed
+aglit start --headless
+aglit status
+aglit disable
+aglit enable
+aglit uninstall
+```
+
+Run `aglit` in an interactive terminal to open the guided setup. `aglit init`
+also runs this flow and installs the signed runtime if it is missing. Setup asks
+for a computer name and whether to keep the app in the background or open its
+Desktop window. **Headless is the default**, including login startup. Headed
+mode is an explicit choice; it shows the same app and profile. `aglit start
+--headless` hides its window without disabling its connection.
+
+Setup opens Aglit's Google login in the browser,
+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 pipelines
+aglit pipelines --open
+aglit init --name "Office Mac" --provider auto --team TEAM_ID
+aglit invite USER_EMAIL --team TEAM_ID
+```
+
+The terminal shows the current account's team memberships and authorized
+pipeline devices. `aglit pipelines --open` opens the existing encrypted pipeline
+viewer for pipeline contents and controls. A device listed in the catalog is not
+proof that its pipelines are connected. Team selection remains invitation
+context; it does not share the newly registered computer.
+
+For unattended setup, use `aglit init --json --name "Office Mac" --provider codex
+--account YOUR_EMAIL --headless`. `--account` checks the actual signed-in
+account before configuration or remote access is enabled; it never selects or
+impersonates an account. JSON mode and redirected input skip interactive prompts.
+Provide 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,197 @@
+#!/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 installation = require('../src/installation.cjs');
+const { createUi, teamsFromRoles } = require('../src/ui.cjs');
+const delay = ms => new Promise(resolve => setTimeout(resolve, ms));
+const help = `Aglit Computer Use
+
+  aglit                         Interactive setup
+  aglit init                    Install and register this computer
+    [--name "Computer name"] [--provider codex|claude|auto]
+    [--account EMAIL] [--headed | --headless] [--team TEAM_ID] [--invite EMAIL]
+  aglit install                 Install the signed Desktop runtime
+  aglit start [--headed | --headless]
+  aglit status [--json]
+  aglit enable | disable
+  aglit teams
+  aglit pipelines [--open]
+  aglit providers
+  aglit invite EMAIL --team TEAM_ID
+  aglit uninstall
+
+Aglit runs in the background by default. --headed opens the Desktop window.
+Use --json with install, init, start or status for non-interactive JSON output.
+Uninstall revokes access and purges only this installation. Mini Computer,
+VMs, shared browser profiles and original provider logins remain separate.
+Team selection does not grant access to this 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();
+      return { uninstalled: true, purged: true };
+    }
+  }
+  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' }, account: { type: 'string' },
+    team: { type: 'string' }, invite: { type: 'string' }, headed: { type: 'boolean' },
+    headless: { type: 'boolean' }, open: { type: 'boolean' }, json: { type: 'boolean' }, help: { type: 'boolean', short: 'h' },
+  }, allowPositionals: true, strict: true });
+  const interactive = Boolean(process.stdin.isTTY && process.stderr.isTTY && !values.json && !process.env.CI);
+  if (values.help || !positionals.length && !interactive) { process.stdout.write(help); return; }
+  const [command = 'init', email] = positionals;
+  const options = {
+    install: ['json'], init: ['name', 'provider', 'account', 'team', 'invite', 'headed', 'headless', 'json'],
+    start: ['headed', 'headless', 'json'], status: ['json'], enable: [], disable: [], teams: ['json'], pipelines: ['open', 'json'], providers: ['json'], 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.headed && values.headless) throw Error('Choose either --headed or --headless');
+  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 validEmail = value => value.length <= 254 && /^[^\s@*]+@[^\s@*]+\.[^\s@*]+$/.test(value);
+  const recipient = command === 'invite' ? email : values.invite;
+  if (recipient && !validEmail(recipient)) throw Error('An individual invitation email address is required');
+  if (values.account !== undefined && !validEmail(values.account)) throw Error('An individual account 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-\x9f]/.test(values.name))) throw Error('Computer name must contain 1–100 printable characters');
+  const ui = await createUi(interactive);
+  const installed = () => fs.existsSync(path.join(installation.root, 'installation.json'));
+  if (command === 'install') {
+    const receipt = await ui.step('Download and verify Desktop', () => installation.install());
+    if (interactive) ui.info('Desktop installed. Run aglit init to register this computer.');
+    else ui.result(receipt);
+    ui.finish('Ready for setup'); return;
+  }
+  if (command === 'status' && !installed()) {
+    ui.result({ product: 'Aglit Computer Use', installed: false, running: false, enabled: false });
+    ui.finish('Run aglit to set up this computer'); return;
+  }
+  if (command === 'uninstall' && !installed()) {
+    if (fs.existsSync(installation.root)) installation.purgeIncomplete();
+    ui.result({ uninstalled: true, purged: true }); ui.finish('Uninstalled'); return;
+  }
+  if ((command === 'uninstall' || command === 'status') && installed()) {
+    const pending = installation.readUninstall();
+    if (pending) {
+      ui.result(command === 'uninstall' ? await finishUninstall(pending) : { installed: true, uninstalling: true, enabled: false });
+      ui.finish('Uninstall cleanup'); return;
+    }
+  }
+  let name = values.name;
+  let mode = values.headed ? 'headed' : 'headless';
+  if (command === 'init') {
+    if (!name && interactive && !installed()) name = await ui.name(os.hostname());
+    if (interactive && values.headed === undefined && values.headless === undefined) mode = await ui.mode();
+    if (!installed()) {
+      if (!interactive && !name) throw Error('Provide --name for unattended setup');
+      await ui.step('Download and verify Desktop', () => installation.install());
+    }
+  }
+  if (!installed()) throw Error('Run aglit init to install and register this computer first.');
+  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') { ui.result({ product: 'Aglit Computer Use', installed: true, running: false, enabled: null, error: error.message }); ui.finish('Runtime stopped'); process.exitCode = 1; return; }
+    state = await ui.step('Start Desktop in the background', async () => {
+      installation.start();
+      const deadline = Date.now() + 60000;
+      while (Date.now() < deadline) {
+        await delay(1000);
+        try { return await control('status'); } catch { /* Wait for this installation's authenticated native socket. */ }
+      }
+      throw Error('Computer Use did not become ready. See runtime.log in its installation directory.');
+    });
+  }
+  if (command === 'status') { ui.result(state); ui.finish('Computer status'); return; }
+  if (command === 'teams' || command === 'pipelines') {
+    const result = await ui.step(command === 'teams' ? 'Load your teams' : 'Load authorized pipeline devices', () => control(command));
+    if (interactive) ui[command](result); else ui.result(result);
+    if (command === 'pipelines' && values.open) await control('open-pipelines');
+    ui.finish(command === 'teams' ? 'Your teams' : 'Your pipelines'); return;
+  }
+  if (command === 'start' || command === 'init') {
+    const window = await control('window', { mode });
+    state = { ...state, ...window };
+    if (command === 'start') { ui.result(state); ui.finish(mode === 'headed' ? 'Desktop window opened' : 'Running in the background'); return; }
+  }
+  if (command === 'init') {
+    if (!state.email) {
+      state = await ui.step('Complete sign-in in your browser', async () => {
+        await control('login');
+        const deadline = Date.now() + 5 * 60000;
+        while (Date.now() < deadline) {
+          await delay(1500); const current = await control('status'); if (current.email) return current;
+        }
+        throw Error('Sign-in timed out. Run aglit init to resume.');
+      });
+    }
+    if (values.account && state.email?.toLowerCase() !== values.account.toLowerCase())
+      throw Error(`Signed in as ${state.email}; expected ${values.account}. Switch the browser sign-in account and rerun aglit init.`);
+    if (interactive && !values.account && !await ui.confirmAccount(state.email))
+      throw Object.assign(Error('Setup cancelled before enabling remote access.'), { cancelled: true });
+    ui.info(`Signed in as ${state.email}`);
+    let teamId = values.team;
+    if (interactive) {
+      const discovery = await ui.step('Load your teams and pipelines', () => Promise.allSettled([control('teams'), control('pipelines')]));
+      let teams = [];
+      if (discovery[0].status === 'fulfilled') { ui.teams(discovery[0].value); teams = teamsFromRoles(discovery[0].value); }
+      else ui.info('Teams are unavailable. You can retry with aglit teams.');
+      if (discovery[1].status === 'fulfilled') ui.pipelines(discovery[1].value);
+      else ui.info('Pipeline devices are unavailable. You can retry with aglit pipelines.');
+      if (!teamId && teams.length) teamId = await ui.team(teams);
+    }
+    name ||= state.name;
+    if (!name && interactive) name = await ui.name(os.hostname());
+    if (!name) throw Error('Provide --name for unattended setup');
+    const detected = await ui.step('Find signed-in AI providers', () => 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 && interactive) provider = await ui.provider(available, detected.preferred);
+    if (!provider || !available.includes(provider)) throw Error('Sign in to Codex or Claude on this computer, then rerun aglit init --provider codex|claude.');
+    await ui.step('Save computer settings', () => control('configure', { name, provider, ...(teamId ? { teamId } : {}) }));
+    const permissions = await ui.step('Check screen recording and input permissions', () => control('permissions'));
+    if (!interactive) ui.result(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.');
+    state = await ui.step('Connect this computer to your account', async () => {
+      await control('enable');
+      const deadline = Date.now() + 30000;
+      do {
+        const current = await control('status');
+        if (current.connected) return current;
+        await delay(1000);
+      } while (Date.now() < deadline);
+      throw Error('Anywhere Access is enabled but its connection is not ready. Check aglit status before retrying.');
+    });
+    if (values.invite) ui.result(await control('invite', { teamId: values.team, email: values.invite }));
+    ui.result(state); ui.finish('Computer ready · https://console.aglit.ai/'); return;
+  }
+  if (command === 'invite') { ui.result(await control('invite', { teamId: values.team, email })); ui.finish('Invitation sent'); 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');
+    ui.result(await ui.step('Remove this installation', () => finishUninstall(result)));
+    ui.finish('Uninstalled'); return;
+  }
+  ui.result(await control(command)); ui.finish('Done');
+}
+
+main().then(() => process.exit(process.exitCode || 0), error => {
+  if (!error.cancelled) process.stderr.write(`aglit: ${error.message}\n`);
+  process.exit(error.cancelled ? 130 : 1);
+});

package/package.json

@@ -1,6 +1,25 @@
 {
   "name": "@aglit-ai/cli",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.2",
+  "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": {
+    "@clack/prompts": "1.8.1",
+    "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 };

package/src/ui.cjs

@@ -0,0 +1,81 @@
+'use strict';
+
+const clean = value => String(value ?? '').replace(/[\x00-\x1f\x7f-\x9f]/g, '');
+function teamsFromRoles(value) {
+  const teams = new Map();
+  for (const company of value?.companies || []) {
+    for (const team of [...(company.teams || []), ...(company.organizations || []).flatMap(organization => organization.teams || [])]) {
+      if (typeof team.teamId === 'string') teams.set(team.teamId, { id: team.teamId, roles: team.roles || [] });
+    }
+  }
+  for (const role of value?.roles || []) {
+    const id = role.teamId || (role.scopeType === 'team' ? role.scopeId : null);
+    if (typeof id === 'string' && !teams.has(id)) teams.set(id, { id, roles: [role.roleLabel || role.role].filter(Boolean) });
+  }
+  return [...teams.values()];
+}
+async function createUi(interactive) {
+  if (!interactive) return {
+    interactive: false,
+    step: (_label, action) => action(),
+    result: value => process.stdout.write(JSON.stringify(value, null, 2) + '\n'),
+    info: message => process.stderr.write(message + '\n'),
+    finish() {},
+  };
+  const p = await import('@clack/prompts');
+  p.intro('Aglit Computer Use');
+  async function answer(promise) {
+    const value = await promise;
+    if (p.isCancel(value)) {
+      p.cancel('Setup cancelled.');
+      throw Object.assign(Error('Setup cancelled'), { cancelled: true });
+    }
+    return value;
+  }
+  return {
+    interactive: true,
+    name: initialValue => answer(p.text({ message: 'Name this computer', placeholder: initialValue, defaultValue: initialValue,
+      validate: value => value && (!value.trim() || value.length > 100 || /[\x00-\x1f\x7f-\x9f]/.test(value)) ? 'Use 1–100 printable characters.' : undefined })),
+    mode: () => answer(p.select({ message: 'How should Aglit run?', initialValue: 'headless', options: [
+      { value: 'headless', label: 'Headless', hint: 'default · background' },
+      { value: 'headed', label: 'Open Desktop window', hint: 'headed' },
+    ] })),
+    provider: (providers, preferred) => answer(p.select({ message: 'Choose your AI provider', initialValue: preferred,
+      options: providers.map(value => ({ value, label: value === 'codex' ? 'Codex' : 'Claude' })) })),
+    team: teams => answer(p.select({ message: 'Team for invitations', initialValue: '', options: [
+      { value: '', label: 'Personal computer', hint: 'access stays with your account' },
+      ...teams.map(team => ({ value: team.id, label: clean(team.id), hint: team.roles.map(clean).join(', ') })),
+    ] })),
+    teams(value) {
+      const teams = teamsFromRoles(value);
+      p.note(teams.length ? teams.map(team => `${clean(team.id)}  ${team.roles.map(clean).join(', ')}`).join('\n') : 'No team memberships.', 'Your teams');
+      return teams;
+    },
+    pipelines(value) {
+      p.note((value.devices.length ? value.devices.map(device => `${clean(device.name)}${device.platform ? ' · ' + clean(device.platform) : ''}`).join('\n') + '\n\n' : 'No authorized pipeline devices.\n\n') +
+        'https://pipelines.aglit.ai/\nOpen the encrypted viewer with aglit pipelines --open.', 'Pipeline devices');
+    },
+    confirmAccount: email => answer(p.confirm({ message: `Register with ${clean(email)}?`, initialValue: true })),
+    async step(label, action) {
+      const spinner = p.spinner(); spinner.start(label);
+      try { const value = await action(); spinner.stop(label); return value; }
+      catch (error) { spinner.stop('Setup paused'); throw error; }
+    },
+    result(value) {
+      if (value.product === 'Aglit Computer Use') {
+        p.note([
+          value.name && `Computer  ${clean(value.name)}`,
+          value.email && `Account   ${clean(value.email)}`,
+          `Runtime   ${value.running ? 'running' : value.installed ? 'stopped' : 'not installed'}`,
+          value.mode && `Window    ${value.windowVisible ? 'open' : 'hidden'}`,
+          `Access    ${value.connected ? 'connected' : value.enabled ? 'connecting' : 'disabled'}`,
+          value.provider && `Provider  ${clean(value.provider)}`,
+        ].filter(Boolean).join('\n'), 'This computer');
+      } else p.log.info(JSON.stringify(value, null, 2));
+    },
+    info: message => p.log.info(clean(message)),
+    finish: message => p.outro(message),
+  };
+}
+
+module.exports = { createUi, teamsFromRoles };