@aglit-ai/cli 0.1.9 → 0.1.11

package/README.md

@@ -8,8 +8,8 @@ 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 ui
+aglit start
 aglit status
 aglit disable
 aglit enable
@@ -18,10 +18,9 @@ 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.
+for a computer name and AI provider, then enables Anywhere Access. It runs in
+the background without a window-mode prompt. After setup, `aglit ui`
+opens the Desktop window using the same app and profile. `aglit start` 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
@@ -32,21 +31,25 @@ accounts remain owned by the user; uninstall does not delete their original logi
 ```sh
 aglit init --name "Office Mac" --provider codex
 aglit providers
-aglit teams
+aglit rename --name "Office Mac"
+aglit console
+aglit team --name "My team"
+aglit teams --open
 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.
+Setup registers a Personal computer with your signed-in account. It asks for its
+name and AI provider, requests the required OS permissions, guides installation of
+the Aglit AI Chrome extension, and enables Anywhere Access. Team selection and
+pipeline discovery are separate from setup.
+Use `aglit team --name "My team"` to associate this computer with a team on your account. The CLI derives its installed workspace; no server-side workspace record or private-key provisioning is required. Manage invitations at teams.aglit.ai.
+Use `aglit teams` to inspect memberships and `aglit pipelines --open` to open the
+encrypted pipeline viewer. A listed device does not prove its pipelines are connected.
 
 For unattended setup, use `aglit init --json --name "Office Mac" --provider codex
---account YOUR_EMAIL --headless`. `--account` checks the actual signed-in
+--account YOUR_EMAIL`. `--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
@@ -65,7 +68,7 @@ Successful registration prints the direct employee link at
 `https://console.aglit.ai/employees/<device-id>` and includes it as `employeeUrl`
 in JSON output.
 
-`--team` selects the existing backend team/invitation scope. It does not grant team
+`aglit invite EMAIL --team TEAM_ID` uses the existing backend 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
@@ -126,3 +129,11 @@ No port change has shipped; provider registration and native acceptance remain
 required before qualifying coexistence.
 
 Anywhere Access requires a two-factor security code by default; an explicit off preference is preserved. In CLI headless mode, incoming connection requests display the code in a native window without opening the full app. This requires a logged-in graphical desktop session; an SSH-only/server environment cannot display the prompt. Codes are not printed to the terminal.
+
+After computer-use permissions, setup opens the published Aglit AI Chrome Web Store
+listing. Choose Add to Chrome and approve Chrome’s prompt. Setup waits until the
+Store extension is installed and enabled in Chrome’s selected profile; it never
+changes a disabled extension setting or browser policy. Installation detection is
+separate from browser-control connectivity.
+
+This release supports Apple Silicon Macs. Windows publication is deferred until its signed native runtime is available.

package/bin/aglit.cjs

@@ -4,34 +4,50 @@ 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 updates = require('../src/updates.cjs');
-const { createUi, teamsFromRoles } = require('../src/ui.cjs');
+const { createUi } = require('../src/ui.cjs');
 const delay = ms => new Promise(resolve => setTimeout(resolve, ms));
+function assertSetupRuntime(state) {
+  if (!Number.isSafeInteger(state.setupVersion) || state.setupVersion < 2)
+    throw Error('This CLI requires a newer Aglit Computer Use runtime. Run aglit update, then rerun aglit init.');
+}
 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] [--channel latest|canary|embedded]
-    [--team TEAM_ID] [--invite EMAIL]
+    [--account EMAIL] [--channel latest|canary|embedded]
   aglit install                 Install the signed Desktop runtime
-  aglit start [--headed | --headless]
+  aglit start
+  aglit ui
   aglit status [--json]
+  aglit rename --name "Computer name"
+  aglit console
   aglit update [--check] [--channel latest|canary|embedded] [--json]
   aglit updates on|off|status [--json]
   aglit enable | disable
-  aglit teams
+  aglit teams [--open]
+  aglit team --name "Team name" [--team TEAM_ID] [--workspace WORKSPACE_ID]
   aglit pipelines [--open]
   aglit providers
+  aglit models list | choose
+  aglit models publish | unpublish --connection CONNECTION_ID --model MODEL_ID
+  aglit models register --device DEVICE_ID --fingerprint SHA256 [--name NAME]
+  aglit models prefer CONNECTION_ID|auto
+  aglit models remove CONNECTION_ID
+  aglit models pool POOL_ID --name NAME --connections local:ACCOUNT_A,local:ACCOUNT_B
+  aglit models test --model MODEL_ID [--connection CONNECTION_ID] [--harness]
+  aglit models unserve
   aglit invite EMAIL --team TEAM_ID
   aglit uninstall
 
-Aglit runs in the background by default. --headed opens the Desktop window.
+Aglit runs in the background. Use aglit ui to open 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.
+Setup registers a Personal computer. Team invitations are separate commands.
 `;
 
 async function finishUninstall(receipt) {
@@ -48,30 +64,33 @@ async function finishUninstall(receipt) {
 }
 
 async function main() {
-  const delegated = updates.delegate(__filename); if (delegated !== null) { process.exitCode = delegated; return; }
+  const delegated = installation.development ? null : updates.delegate(__filename); if (delegated !== null) { process.exitCode = delegated; return; }
   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' }, check: { type: 'boolean' }, channel: { type: 'string' }, open: { type: 'boolean' }, json: { type: 'boolean' }, help: { type: 'boolean', short: 'h' },
+    connections: { type: 'string' },
+    harness: { type: 'boolean' },
+    device: { type: 'string' }, fingerprint: { type: 'string' }, challenge: { type: 'string' }, code: { type: 'string' }, connection: { type: 'string' }, model: { type: 'string' }, name: { type: 'string' }, provider: { type: 'string' }, account: { type: 'string' },
+    team: { type: 'string' }, workspace: { type: 'string' }, check: { type: 'boolean' }, channel: { type: 'string' }, 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 [command = 'init', email, connectionId] = positionals;
   const options = {
-    install: ['json', 'channel'], init: ['name', 'provider', 'account', 'team', 'invite', 'headed', 'headless', 'json', 'channel'],
-    start: ['headed', 'headless', 'json', 'channel'], status: ['json'], update: ['check', 'channel', 'json'], updates: ['json'], enable: [], disable: [], teams: ['json'], pipelines: ['open', 'json'], providers: ['json'], invite: ['team'], uninstall: [],
+    models: ['device','fingerprint','name','json','challenge','code','connection','connections','model','harness'],
+    install: ['json', 'channel'], init: ['name', 'provider', 'account', 'json', 'channel'],
+    start: ['json', 'channel'], ui: ['json'], status: ['json'], update: ['check', 'channel', 'json'], updates: ['json'], enable: [], disable: [], rename: ['name', 'json'], console: ['json'], teams: ['json', 'open'], team: ['name', 'team', 'workspace', '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 > (['invite', 'updates'].includes(command) ? 2 : 1)) throw Error('Invalid command or options. Run aglit --help.');
+  if (!Object.hasOwn(options, command) || Object.keys(values).some(key => !options[command].includes(key)) || positionals.length > (command === 'models' ? 3 : ['invite', 'updates'].includes(command) ? 2 : 1)) throw Error('Invalid command or options. Run aglit --help.');
+  if (installation.development && !['models','status','init','providers','enable','disable','ui','start'].includes(command)) throw Error('Source profile supports model/setup, access and window commands; installed runtime management is separate');
   if (command === 'updates' && !['on', 'off', 'status'].includes(email)) throw Error('Use aglit updates on|off|status');
   if (values.channel !== undefined && !['latest', 'canary', 'embedded'].includes(values.channel)) throw Error('Update channel must be latest, canary or embedded');
-  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');
+  if (values.provider && !/^[a-z0-9._-]{1,64}$/.test(values.provider)) throw Error('Invalid provider');
+  if (command === 'models') require('../src/model-connections.cjs').validateModelCommand(email,connectionId,values);
   const validEmail = value => value.length <= 254 && /^[^\s@*]+@[^\s@*]+\.[^\s@*]+$/.test(value);
-  const recipient = command === 'invite' ? email : values.invite;
+  const recipient = command === 'invite' ? email : undefined;
   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 (command === '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'));
@@ -108,10 +127,8 @@ async function main() {
     }
   }
   let name = values.name;
-  let mode = values.headed ? 'headed' : 'headless';
+  const mode = command === 'ui' ? '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(values.channel));
@@ -119,11 +136,11 @@ async function main() {
   }
   if (!installed()) throw Error('Run aglit init to install and register this computer first.');
   installation.readInstallation();
-  if (['start', 'init'].includes(command)) {
+  if (!installation.development && ['start', 'ui', 'init'].includes(command)) {
     const recovered = await updates.recoverActivation();
     if (recovered.updating) { ui.result(recovered); ui.finish('Update in progress'); return; }
   }
-  if (['start', 'init'].includes(command)) updates.initialize(values.channel);
+  if (!installation.development && ['start', 'ui', 'init'].includes(command)) updates.initialize(values.channel);
   const configPath = path.join(installation.profile, 'ipc/sdk-ipc.json');
   const control = (action, fields = {}) => require('../src/control.cjs').control(configPath, action, fields);
   let state;
@@ -150,21 +167,44 @@ async function main() {
       throw Error('Computer Use did not become ready. See runtime.log in its installation directory.');
     });
   }
-  if (state.running && ['status', 'start', 'init'].includes(command)) updates.rememberStatus(state);
-  if (['start', 'init'].includes(command) && state.running) updates.ensureWorker(state.pid);
+  if (!installation.development && state.running && ['status', 'start', 'ui', 'init'].includes(command)) updates.rememberStatus(state);
+  if (!installation.development && ['start', 'ui', 'init'].includes(command) && state.running) updates.ensureWorker(state.pid);
+  const modelQuestion = interactive ? async text => {
+    const prompt = createInterface({ input: process.stdin, output: process.stderr });
+    try { return await prompt.question(text); } finally { prompt.close(); }
+  } : undefined;
+  if (command === 'models') {
+    ui.result(await require('../src/model-connections.cjs').modelCommand(control,email,connectionId,values,modelQuestion));
+    ui.finish('Model connections'); return;
+  }
   if (command === 'status') { ui.result(state); ui.finish('Computer status'); return; }
+  if (command === 'console') { ui.result({ url: state.consoleUrl }); ui.finish('Console'); return; }
+  if (command === 'rename') {
+    if (!values.name) throw Error('Provide --name to rename this computer');
+    ui.result(await control('configure', { name: values.name })); ui.finish('Computer renamed'); return;
+  }
+  if (command === 'team') {
+    if (!values.name) throw Error('Provide --name for the team');
+    ui.result(await ui.step('Set up your team', () => control('setup-team', {
+      name: values.name, ...(values.team ? { teamId: values.team } : {}),
+      ...(values.workspace ? { workspaceId: values.workspace } : {}),
+    })));
+    ui.finish('Manage your team at https://teams.aglit.ai/'); 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 === 'teams' && values.open) await control('open-teams');
     if (command === 'pipelines' && values.open) await control('open-pipelines');
     ui.finish(command === 'teams' ? 'Your teams' : 'Your pipelines'); return;
   }
-  if (command === 'start' || command === 'init') {
+  if (command === 'start' || command === 'ui') {
     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; }
+    ui.result(state); ui.finish(mode === 'headed' ? 'Desktop window opened' : 'Running in the background'); return;
   }
   if (command === 'init') {
+    assertSetupRuntime(state);
     if (!state.email) {
       state = await ui.step('Complete sign-in in your browser', async () => {
         await control('login');
@@ -180,33 +220,32 @@ async function main() {
     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);
-    }
+    if (!values.name && interactive) name = await ui.name(state.name || os.hostname());
     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 : values.provider === 'auto' ?
-        ['codex', 'claude'].find(candidate => available.includes(candidate)) : 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.');
-    ui.info(`AI provider: ${provider}`);
-    await ui.step('Save computer settings', () => control('configure', { name, provider, ...(teamId ? { teamId } : {}) }));
-    if (process.platform === 'darwin') ui.info('Approve the macOS screen recording and input-control requests. Setup waits for each permission before continuing. Previously denied permissions must be enabled in System Settings.');
+    const selected = await require('../src/model-connections.cjs').chooseModelConnection(control, { provider: values.provider, question: modelQuestion });
+    for (const warning of selected.view.warnings || []) ui.info(warning);
+    await ui.step('Save computer settings', () => control('configure', { name,
+      ...(selected.connectionId ? { provider: 'aglit', model_connection_id: selected.connectionId } : values.provider && values.provider !== 'auto' ? { provider: values.provider } : {}) }));
+    if (process.platform === 'darwin') ui.permissions();
     const permissions = await ui.step('Waiting for 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.');
+    let browser = await ui.step('Check Aglit AI browser extension', () => control('browser-status'));
+    if (!browser.enabled) {
+      const prepared = await ui.step('Set up Aglit AI browser extension', () => control('browser-setup'));
+      ui.browserExtension(prepared);
+      browser = await ui.step('Waiting for Chrome extension installation', async () => {
+        const deadline = Date.now() + 180000;
+        do {
+          const current = await control('browser-status');
+          if (current.installed && current.enabled) return current;
+          await delay(1500);
+        } while (Date.now() < deadline);
+        throw Error('Add or enable the Aglit AI Chrome extension, then rerun aglit init.');
+      });
+    }
     state = await ui.step('Connect this computer to your account', async () => {
       await control('enable');
       const deadline = Date.now() + 30000;
@@ -217,11 +256,10 @@ async function main() {
       } 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 }));
-    updates.rememberStatus(state);
+    if (!installation.development) updates.rememberStatus(state);
     if (typeof state.deviceId !== 'string' || !state.deviceId) throw Error('Registration returned no device ID. Check aglit status before retrying.');
     state = { ...state, employeeUrl: `https://console.aglit.ai/employees/${encodeURIComponent(state.deviceId)}` };
-    ui.result(state); ui.finish(`Computer ready · ${state.employeeUrl}`); return;
+    ui.result(state); ui.finish('Anywhere Access enabled'); return;
   }
   if (command === 'invite') { ui.result(await control('invite', { teamId: values.team, email })); ui.finish('Invitation sent'); return; }
   if (command === 'uninstall') {
@@ -236,7 +274,8 @@ async function main() {
   ui.result(await control(command)); ui.finish('Done');
 }
 
-main().catch(error => {
+module.exports = {assertSetupRuntime};
+if (require.main === module) main().catch(error => {
   if (!error.cancelled) process.stderr.write(`aglit: ${error.message}\n`);
   process.exitCode = error.cancelled ? 130 : 1;
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aglit-ai/cli",
-  "version": "0.1.9",
+  "version": "0.1.11",
   "description": "Install and manage Aglit Computer Use",
   "license": "UNLICENSED",
   "type": "commonjs",
@@ -12,6 +12,12 @@
     "src",
     "README.md"
   ],
+  "os": [
+    "darwin"
+  ],
+  "cpu": [
+    "arm64"
+  ],
   "engines": {
     "node": ">=22"
   },

package/src/control.cjs

@@ -22,7 +22,7 @@ function control(configPath, action, fields = {}) {
     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 timeout = setTimeout(() => finish(Error('Native command timed out; its outcome may be uncertain. Check aglit status before retrying.')), action === 'permissions' ? 5 * 60000 : ['enable','models-test'].includes(action) ? 120000 : 30000);
     const finish = (error, result) => {
       if (settled) return;
       settled = true; clearTimeout(timeout); socket.destroy();

package/src/installation.cjs

@@ -8,7 +8,8 @@ const { pipeline } = require('node:stream/promises');
 const { once } = require('node:events');
 const { createRequire } = require('node:module');
 
-const root = path.join(process.platform === 'darwin' ? path.join(os.homedir(), 'Library/Application Support') :
+const development = process.env.AGLIT_DEV_COMPUTER_USE_ROOT ? require('../../desktop-app/shared/computer-use-development.cjs').readComputerUseDevelopment() : null;
+const root = development?.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');
@@ -51,9 +52,9 @@ function readInstallation(allowPartialCleanup = false) {
   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 ||
+  if (value.kind !== (development ? 'aglit-computer-use-development-v1' : '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');
+      (!development && !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;
 }
@@ -195,6 +196,7 @@ async function install(channel) {
   return { installed: true, ...receipt };
 }
 function start() {
+  if (development) throw Error('Start the source runtime with scripts/dev/run-computer-use.cjs before invoking this CLI');
   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"}']);
@@ -262,4 +264,4 @@ function readUninstall() {
       !Number.isSafeInteger(receipt.pid) || receipt.pid <= 0) throw Error('Invalid uninstall receipt');
   return receipt;
 }
-module.exports = { root, profile, readInstallation, install, start, purge, purgeIncomplete, readUninstall, privateRoot, canonical, verifyPublisher, embeddedRelease, copyArchive, stageRuntime, verifyRuntime };
+module.exports = { development, root, profile, readInstallation, install, start, purge, purgeIncomplete, readUninstall, privateRoot, canonical, verifyPublisher, embeddedRelease, copyArchive, stageRuntime, verifyRuntime };

package/src/model-connections.cjs

@@ -0,0 +1,109 @@
+'use strict';
+/** UI-free selection policy lives in runtime-api; the CLI prompts only on its
+ * explicit choice-required result, then persists the choice through native control. */
+async function listModelConnections(control) {
+  try {
+    const view = await control('models-list');
+    if (!view || !Array.isArray(view.connections) || !view.selection || typeof view.selection.status !== 'string') throw Error('Invalid discovery response');
+    return view;
+  } catch {
+    return { connections: [], selection: { status: 'discovery-unavailable', connection_id: null },
+      warnings: ['Model endpoint discovery is unavailable. Existing provider settings are unchanged; retry aglit models list later.'] };
+  }
+}
+async function chooseModelConnection(control, { provider, question } = {}) {
+  let view = await listModelConnections(control);
+  if (view.selection.status === 'discovery-unavailable') return { view, connectionId: null, unavailable: true };
+  // Init/choose is an explicit connection action. Passive models-list never
+  // prompts; reconnect only the saved/chosen endpoint, never every known host.
+  if (['preferred-unavailable','setup-required'].includes(view.selection.status)) {
+    const remote = view.connections.filter(value => value.kind === 'remote');
+    let target = view.preferred_connection_id ? remote.find(value => value.id === view.preferred_connection_id) : remote.length === 1 ? remote[0] : undefined;
+    let chosen = false;
+    if (!target && !view.preferred_connection_id && remote.length > 1) {
+      if (!question) throw Error('More than one model connection is available. Run aglit models choose.');
+      const answer = (await question(remote.map((value,index)=>`${index+1}. ${value.name}`).join('\n')+'\nModel connection: ')).trim();
+      if (!/^[1-9]\d*$/.test(answer) || !remote[Number(answer)-1]) throw Error('Choose a listed model connection');
+      target = remote[Number(answer)-1]; chosen = true;
+    }
+    if (target) {
+      view = await modelCommand(control,'register',undefined,{device:target.device_id,fingerprint:target.identity_fingerprint,name:target.name},question);
+      if (chosen) view = await control('models-prefer',{connection_id:target.id});
+    }
+  }
+  let selection = view.selection;
+  if (provider && provider !== 'auto' && provider !== 'aglit') {
+    const candidates = view.connections.filter(value => value.available && value.models.some(model => model.provider === provider));
+    if (candidates.length === 1) {
+      view = await control('models-prefer', { connection_id: candidates[0].id }); selection = view.selection;
+    } else if (!candidates.length) throw Error('No connected account supplies that provider');
+    else { view = { ...view, connections: candidates }; selection = { status: 'choice-required', connection_id: null }; }
+  }
+  if (selection.status === 'choice-required') {
+    if (!question) throw Error('More than one model connection is available. Run aglit models choose or aglit models prefer CONNECTION_ID.');
+    const choices = view.connections.filter(value => value.available && value.models.length);
+    const answer = await question(choices.map((value,index)=>`${index+1}. ${value.name}`).join('\n')+'\nModel connection: ');
+    if (!/^[1-9]\d*$/.test(answer.trim()) || !choices[Number(answer.trim())-1]) throw Error('Choose a listed model connection');
+    view = await control('models-prefer', { connection_id: choices[Number(answer.trim())-1].id }); selection = view.selection;
+  }
+  if (selection.status === 'preferred-unavailable') throw Error('Your saved model connection is unavailable. Reconnect it or explicitly choose another with aglit models prefer CONNECTION_ID.');
+  if (selection.status !== 'selected') throw Error('No model connection is ready. Connect a local provider or register an Aglit model endpoint.');
+  return { view, connectionId: selection.connection_id };
+}
+function validateModelCommand(command, id, values) {
+  const allowed = {list:['json'],test:['connection','model','harness'],choose:[],pool:['name','connections'],publish:['connection','model'],unpublish:['connection','model'],unserve:[],register:['device','fingerprint','name','challenge','code'],prefer:[],remove:[]};
+  if (!Object.hasOwn(allowed,command) || Object.keys(values).some(key=>!allowed[command].includes(key)) ||
+      (!['prefer','remove','pool'].includes(command) && id) || (['prefer','remove','pool'].includes(command) && !id)) throw Error('Invalid model command or options');
+  if (command === 'pool' && (!/^[A-Za-z0-9._-]{1,80}$/.test(id) || !values.name?.trim() || values.name.length > 100 ||
+      typeof values.connections !== 'string' || values.connections.length > 6400 || !values.connections.split(',').every(value => /^local:[A-Za-z0-9._:-]{1,180}$/.test(value) && !value.startsWith('local:pool:'))))
+    throw Error('Use aglit models pool POOL_ID --name NAME --connections local:ACCOUNT_A,local:ACCOUNT_B');
+  if (command === 'register' && (!/^[A-Za-z0-9._:-]{1,180}$/.test(values.device || '') || !/^[a-f0-9]{64}$/.test(values.fingerprint || '')))
+    throw Error('Use --device DEVICE_ID and --fingerprint with the endpoint SHA-256 fingerprint');
+  if (Boolean(values.challenge) !== Boolean(values.code) || values.code && !/^[0-9]{4,12}$/.test(values.code) ||
+      values.challenge && (!/^[A-Za-z0-9._:-]{1,256}$/.test(values.challenge))) throw Error('Supply both --challenge and a numeric --code');
+  if (id && !/^[A-Za-z0-9._:-]{1,200}$/.test(id)) throw Error('Invalid model connection ID');
+  if (['publish','unpublish'].includes(command) && (!/^local:[A-Za-z0-9._:-]{1,180}$/.test(values.connection||'') || !/^[A-Za-z0-9][A-Za-z0-9._:/-]{0,255}$/.test(values.model||''))) throw Error('Choose a local --connection and --model');
+  if (command === 'remove' && !id.startsWith('remote:')) throw Error('A registered remote connection ID is required');
+}
+async function modelCommand(control, command, id, values, question) {
+  validateModelCommand(command,id,values);
+  if (command === 'list') return listModelConnections(control);
+  if (command === 'test') {
+    if (!/^[A-Za-z0-9][A-Za-z0-9._:/-]{0,255}$/.test(values.model || '') || values.connection && !/^[A-Za-z0-9._:-]{1,200}$/.test(values.connection)) throw Error('Use aglit models test --model MODEL_ID [--connection CONNECTION_ID]');
+    return control('models-test', { model_id: values.model, ...(values.connection ? { connection_id: values.connection } : {}), ...(values.harness ? { harness: 'true' } : {}) });
+  }
+  if (command === 'pool') return control('models-pool-save', { pool_id: 'local:pool:' + id, name: values.name,
+    connection_ids: JSON.stringify(values.connections.split(',')) });
+  if (command === 'register') {
+    if (!values.device || !values.fingerprint || id) throw Error('Use aglit models register --device DEVICE_ID --fingerprint SHA256 [--name NAME]');
+    if (Boolean(values.challenge) !== Boolean(values.code) || values.code && !/^[0-9]{4,12}$/.test(values.code)) throw Error('Supply both --challenge and a numeric --code');
+    const fields = {device_id:values.device,identity_fingerprint:values.fingerprint,name:values.name||values.device, ...(values.challenge ? {challenge_id:values.challenge,code:values.code} : {})};
+    let result = await control('models-register',fields);
+    let consoleUrl;
+    if (typeof result.console_url === 'string') {
+      try { const url = new URL(result.console_url);
+        if ((url.protocol === 'https:' || process.env.NODE_ENV === 'development' && url.protocol === 'http:' && url.hostname === '127.0.0.1') &&
+            !url.username && !url.password && !url.search && !url.hash && url.pathname === '/employees/' + encodeURIComponent(values.device)) consoleUrl = url.href;
+      } catch { /* Never present an unvalidated authentication destination. */ }
+    }
+    const instructions = `A security-code dialog appears on ${fields.name}. Check that device.` +
+      (consoleUrl ? ` Open its console on that device if needed: ${consoleUrl}` : '');
+    if (result.authentication_required && result.challenge_id && question) {
+      const code = (await question(instructions + '\nRemote Access authentication code: ')).trim();
+      if (!/^[0-9]{4,12}$/.test(code)) throw Error('A numeric Remote Access code is required');
+      result = await control('models-register',{...fields,challenge_id:result.challenge_id,code});
+    }
+    if (result.authentication_required) throw Error(instructions + ' Complete registration with --challenge CHALLENGE_ID --code CODE' +
+      (result.challenge_id ? ' (challenge '+result.challenge_id+')' : ''));
+    return result;
+  }
+  if (command === 'prefer' || command === 'remove') {
+    if (!id || !/^[A-Za-z0-9._:-]{1,200}$/.test(id)) throw Error('A model connection ID is required');
+    return control(command==='prefer'?'models-prefer':'models-remove',{connection_id:command==='prefer'&&id==='auto'?'':id});
+  }
+  if (command === 'publish' || command === 'unpublish') return control('models-publish',{connection_id:values.connection,model_id:values.model,published:String(command==='publish')});
+  if (command === 'unserve') return control('models-unpublish-all');
+  if (command === 'choose') return (await chooseModelConnection(control,{question})).view;
+  throw Error('Use aglit models list|register|prefer|remove|publish|unpublish|unserve|choose');
+}
+module.exports={chooseModelConnection,listModelConnections,modelCommand,validateModelCommand};

package/src/runtime-download.cjs

@@ -0,0 +1,77 @@
+'use strict';
+const fs = require('node:fs');
+const path = require('node:path');
+const os = require('node:os');
+const crypto = require('node:crypto');
+const { execFile } = require('node:child_process');
+const { promisify } = require('node:util');
+const run = promisify(execFile);
+const need = (value, message) => { if (!value) throw Error(message); };
+
+// Read a single payload from a verified npm tarball. Native tar writes only to
+// stdout: package paths, links and lifecycle scripts never write into the guest.
+async function packageFile(manifest, file, maximum, signal = AbortSignal.timeout(120000)) {
+  const url = new URL(manifest.dist.tarball);
+  need(url.protocol === 'https:' && url.hostname === 'registry.npmjs.org' && !url.port && !url.username && !url.password &&
+    /^sha512-[A-Za-z0-9+/]{86}==$/.test(manifest.dist.integrity), 'Untrusted runtime npm package');
+  need(['runtime/desktop-runtime.json', 'runtime/part.bin'].includes(file), 'Unknown runtime payload');
+  const directory = fs.mkdtempSync(path.join(fs.realpathSync(os.tmpdir()), 'aglit-runtime-'));
+  const archive = path.join(directory, 'package.tgz');
+  try {
+    const response = await fetch(url, {redirect: 'error', signal: AbortSignal.any([signal, AbortSignal.timeout(120000)])});
+    need(response.ok && response.body, 'Runtime npm download unavailable');
+    const fd = fs.openSync(archive, 'wx', 0o600), digest = crypto.createHash('sha512');
+    let size = 0;
+    try {
+      for await (const chunk of response.body) {
+        size += chunk.length; need(size <= maximum + 2 * 1024 ** 2, 'Runtime npm package exceeds limit');
+        digest.update(chunk);
+        let offset = 0;
+        while (offset < chunk.length) offset += fs.writeSync(fd, chunk, offset, chunk.length - offset);
+      }
+      need('sha512-' + digest.digest('base64') === manifest.dist.integrity, 'Runtime npm integrity differs');
+    } finally { fs.closeSync(fd); }
+    const tar = process.platform === 'win32' ? path.join(process.env.SystemRoot || 'C:\\Windows', 'System32/tar.exe') : '/usr/bin/tar';
+    const {stdout} = await run(tar, ['-xOf', archive, 'package/' + file], {encoding: 'buffer', maxBuffer: maximum + 1, timeout: 30000, windowsHide: true});
+    need(stdout.length > 0 && stdout.length <= maximum, 'Runtime payload exceeds limit');
+    return stdout;
+  } finally { fs.rmSync(directory, {recursive: true, force: true}); }
+}
+
+// The same verified part stream feeds normal downloads and native baseline
+// admission, whose existing descriptor custody stays owned by its native worker.
+async function* archiveParts({descriptor, parts, signal}) {
+  need(parts.length === descriptor.chunks.length && parts.length > 0 && parts.length <= 32, 'Runtime part graph differs');
+  const sha256 = crypto.createHash('sha256'), sha512 = crypto.createHash('sha512');
+  let received = 0;
+  for (const [index, part] of descriptor.chunks.entries()) {
+    need(parts[index].name === part.package && parts[index].version === part.version, 'Runtime part identity differs');
+    const bytes = await packageFile(parts[index], part.file, part.size, signal);
+    need(bytes.length === part.size && crypto.createHash('sha256').update(bytes).digest('hex') === part.sha256 &&
+      crypto.createHash('sha512').update(bytes).digest('base64') === part.sha512, 'Runtime part checksum differs');
+    received += bytes.length; sha256.update(bytes); sha512.update(bytes);
+    yield bytes;
+  }
+  need(received === descriptor.archive.size && sha256.digest('hex') === descriptor.archive.sha256 &&
+    sha512.digest('base64') === descriptor.archive.sha512, 'Runtime archive checksum differs');
+}
+
+async function downloadArchive({descriptor, parts, destination, onProgress = () => {}}) {
+  const fd = fs.openSync(destination, 'wx', 0o600), owned = fs.fstatSync(fd);
+  let received = 0, verified = false;
+  try {
+    for await (const bytes of archiveParts({descriptor, parts})) {
+      let offset = 0;
+      while (offset < bytes.length) offset += fs.writeSync(fd, bytes, offset, bytes.length - offset);
+      received += bytes.length; onProgress(received);
+    }
+    fs.fsyncSync(fd); verified = true;
+  } finally {
+    fs.closeSync(fd);
+    if (!verified) {
+      const current = fs.lstatSync(destination);
+      if (current.dev === owned.dev && current.ino === owned.ino && current.isFile() && !current.isSymbolicLink()) fs.unlinkSync(destination);
+    }
+  }
+}
+module.exports = {packageFile, archiveParts, downloadArchive};

package/src/ui.cjs

@@ -2,17 +2,7 @@
 
 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()];
+  return (value?.teams || []).map(team => ({ id: team.teamId, roles: [team.canManage ? 'Administrator' : 'Member'] }));
 }
 async function createUi(interactive) {
   if (!interactive) return {
@@ -20,6 +10,9 @@ async function createUi(interactive) {
     step: (_label, action) => action(),
     result: value => process.stdout.write(JSON.stringify(value, null, 2) + '\n'),
     info: message => process.stderr.write(message + '\n'),
+    selection: (label, value) => process.stderr.write(label + ': ' + clean(value) + '\n'),
+    permissions: () => process.stderr.write('In System Settings → Privacy & Security, enable Aglit Computer Use in Screen Recording and Accessibility. Keep each pane open until its permission is granted. Previously denied permissions must be enabled there manually.\n'),
+    browserExtension: value => process.stderr.write('In Chrome, open '+value.storeUrl+' and choose Add to Chrome. If installed but disabled, enable Aglit AI in chrome://extensions.\n'),
     finish() {},
   };
   const p = await import('@clack/prompts');
@@ -36,16 +29,11 @@ async function createUi(interactive) {
     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(', ') })),
-    ] })),
+    selection: (label, value) => p.log.step(clean(label) + '\n' + clean(value)),
+    permissions: () => p.note('Enable Aglit Computer Use in System Settings → Privacy & Security:\n1. Screen Recording (Screen & System Audio Recording on newer macOS)\n2. Accessibility\n\nSetup waits for each grant before opening the next pane.\nPreviously denied permissions must be enabled there manually.\nIf macOS asks you to quit and reopen Aglit Computer Use, do so and rerun aglit init.', 'Allow screen sharing and input'),
+    browserExtension: value => p.note('Open this listing in Chrome:\n' + clean(value.storeUrl) + '\n\nChoose Add to Chrome and approve the browser prompt.\nIf already installed but disabled, enable Aglit AI in chrome://extensions.\nSetup continues when the extension is installed and enabled.\nInstallation alone does not verify browser-control connectivity.', 'Add Aglit AI to Chrome'),
     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');