@openchambery/web 2.1.8-beta.3 → 2.1.8-beta.5

package/dist/index.html

@@ -552,7 +552,7 @@
         opacity: 0.72;
       }
     </style>
-    <script type="module" crossorigin src="/assets/main-B3grbXe8.js"></script>
+    <script type="module" crossorigin src="/assets/main-BJckugyb.js"></script>
     <link rel="modulepreload" crossorigin href="/assets/rolldown-runtime-hePW80VL.js">
     <link rel="modulepreload" crossorigin href="/assets/runtime-auth-C8w0nlKy.js">
     <link rel="modulepreload" crossorigin href="/assets/runtime-switch-3ad3yzM7.js">
@@ -572,7 +572,7 @@
     <link rel="modulepreload" crossorigin href="/assets/terminalApi-bN5IYQau.js">
     <link rel="modulepreload" crossorigin href="/assets/types-BuiqMmh_.js">
     <link rel="modulepreload" crossorigin href="/assets/capgoAdapter-KNLHDj7G.js">
-    <link rel="modulepreload" crossorigin href="/assets/runtimeConfig-GAVzvQGc.js">
+    <link rel="modulepreload" crossorigin href="/assets/runtimeConfig-Bm1EPWPq.js">
     <link rel="stylesheet" crossorigin href="/assets/src-C9BNQK0O.css">
   </head>
   <body class="h-full bg-background text-foreground">

package/dist/mini-chat.html

@@ -74,7 +74,7 @@
       }
     </style>
 
-    <script type="module" crossorigin src="/assets/miniChat-ChSEmnwp.js"></script>
+    <script type="module" crossorigin src="/assets/miniChat-YVKGcjkV.js"></script>
     <link rel="modulepreload" crossorigin href="/assets/rolldown-runtime-hePW80VL.js">
     <link rel="modulepreload" crossorigin href="/assets/runtime-auth-C8w0nlKy.js">
     <link rel="modulepreload" crossorigin href="/assets/runtime-switch-3ad3yzM7.js">
@@ -94,7 +94,7 @@
     <link rel="modulepreload" crossorigin href="/assets/terminalApi-bN5IYQau.js">
     <link rel="modulepreload" crossorigin href="/assets/types-BuiqMmh_.js">
     <link rel="modulepreload" crossorigin href="/assets/capgoAdapter-KNLHDj7G.js">
-    <link rel="modulepreload" crossorigin href="/assets/runtimeConfig-GAVzvQGc.js">
+    <link rel="modulepreload" crossorigin href="/assets/runtimeConfig-Bm1EPWPq.js">
     <link rel="stylesheet" crossorigin href="/assets/src-C9BNQK0O.css">
   </head>
   <body class="h-full bg-background text-foreground">

package/dist/mobile.html

@@ -63,7 +63,7 @@
       })();
     </script>
 
-    <script type="module" crossorigin src="/assets/mobile-CrKlS4SH.js"></script>
+    <script type="module" crossorigin src="/assets/mobile-DtAt6Tnq.js"></script>
     <link rel="modulepreload" crossorigin href="/assets/rolldown-runtime-hePW80VL.js">
     <link rel="modulepreload" crossorigin href="/assets/runtime-auth-C8w0nlKy.js">
     <link rel="modulepreload" crossorigin href="/assets/runtime-switch-3ad3yzM7.js">
@@ -83,7 +83,7 @@
     <link rel="modulepreload" crossorigin href="/assets/terminalApi-bN5IYQau.js">
     <link rel="modulepreload" crossorigin href="/assets/types-BuiqMmh_.js">
     <link rel="modulepreload" crossorigin href="/assets/capgoAdapter-KNLHDj7G.js">
-    <link rel="modulepreload" crossorigin href="/assets/runtimeConfig-GAVzvQGc.js">
+    <link rel="modulepreload" crossorigin href="/assets/runtimeConfig-Bm1EPWPq.js">
     <link rel="stylesheet" crossorigin href="/assets/src-C9BNQK0O.css">
   </head>
   <body class="h-full bg-background text-foreground">

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openchambery/web",
-  "version": "2.1.8-beta.3",
+  "version": "2.1.8-beta.5",
   "private": false,
   "type": "module",
   "main": "./server/index.js",

package/server/lib/config-sync/DOCUMENTATION.md

@@ -19,6 +19,7 @@ Own the direction-agnostic OpenCode config sync contract: allowlist planning on
 | `engine.js` | `applyConfigSyncPlan` orchestration for **push** (prepare → putTar* → finalize) |
 | `credentials.js` | V2 credential API transfer, validation, account merge and in-memory rollback |
 | `magpie.js` | Host-local Magpie discovery, verified CLI provisioning, native backup/restore |
+| `magpie-auth.js` | Bounded portable authorization export, plugin-store merge and account verification |
 | `target-id.js` | `ssh:<instanceId>` namespace helper |
 
 ## Contract shape
@@ -67,7 +68,7 @@ Routes under `/api/openchamber/config-sync/*` (global `/api` auth gate: session
 | GET | `/credentials/inventory` | Current-service credential byte count, without secrets |
 | PUT | `/credentials` | Bounded credential import for local pull and SSH-forwarded transfer |
 | GET | `/magpie/inventory` | `{ magpie: { available, installed } }`, metadata only; never installs |
-| PUT | `/magpie` | Native Magpie restore for local pull and SSH-forwarded transfer; installs missing CLI |
+| PUT | `/magpie` | Magpie config/authorization restore and verification for local pull and SSH-forwarded transfer; installs missing CLI |
 | POST | `/finalize` | Confirm backup generation + success receipt |
 | POST | `/abort` | Clear inflight |
 
@@ -84,12 +85,16 @@ Routes under `/api/openchamber/config-sync/*` (global `/api` auth gate: session
 
 The existing sync wizard discovers Magpie on the **source** for every preview. A push uses the local host's inventory; a pull uses the selected remote host's inventory (HTTP through the SSH forward, direct, or E2EE Relay). `magpieAvailable` survives selection filtering. The optional `magpie` plan entry is `{ bytes: 0 }` when selected: backup size is unknown until export, not counted as a zero-byte archive. Switching direction clears the Magpie selection and discovers the new source. A selected source disappearing is a failure, never an empty successful sync. This is discovery during the existing explicit sync flow, not a background file watcher.
 
-Discovery checks `MAGPIE_BINARY`, PATH, the user's `.local/bin`, macOS application bundles and Homebrew paths, the standard Windows user installation path, then OpenChamber's managed executable. Symlinks resolve before locating portable data. Installed config honors absolute `XDG_CONFIG_HOME`, otherwise `~/.config/magpie`; portable config follows `.portable` / adjacent `data`, including the macOS app parent and an applicable AppImage directory. A shared Applications/home/download directory's `data` is not adopted over installed config. Providers, settings, profiles, library or plugin config files make the source available even without a CLI. Metadata does not expose paths or secrets. Read errors fail discovery.
+Discovery checks `MAGPIE_BINARY`, PATH, the user's `.local/bin`, macOS application bundles and Homebrew paths, the standard Windows user installation path, then OpenChamber's managed executable. Symlinks resolve before locating portable data. Installed config honors absolute `XDG_CONFIG_HOME`, otherwise `~/.config/magpie`; portable config follows `.portable` / adjacent `data`, including the macOS app parent and an applicable AppImage directory. A shared Applications/home/download directory's `data` is not adopted over installed config. The source is available only when a verified CLI is installed and providers, settings, profiles, library, plugin config or authorization stores exist. Leftover config without an installed CLI does not expose the sync option. Magpie's checkbox and explanatory copy form a separate conditional group, default unchecked; general OpenCode sync copy remains independent. Metadata does not expose paths or secrets. Read errors fail discovery.
 
-Selecting Magpie uses its native `backup` / `restore` with configuration, API keys, profiles, agent models, library and portable plugin declarations. Subscription OAuth and plugin sign-ins are excluded by Magpie itself; the option says so. This does not modify Magpie or copy its login databases. Native provider/group restore merges by ID and does not propagate deletions; settings and library follow Magpie's own restore semantics, retaining machine-local settings. This is a full native bundle, not a provider-only restore.
+Selecting Magpie uses its native `backup` / `restore` with configuration, API keys, profiles, agent models, library and portable plugin declarations. Native provider/group restore merges by ID and does not propagate deletions; settings and library follow Magpie's own restore semantics, retaining machine-local settings. This is a full native bundle, not a provider-only restore.
 
-Missing executables are installed only during selected export/import (including a config-only source), never in preview. The host selects the official pure CLI asset for macOS/Linux/Windows x64/arm64 from `https://usemagpie.ai/api/latest`, verifies SHA-256, checks `--version`, then atomically publishes it under `<OPENCHAMBER_DATA_DIR>/tools/magpie/` (default `~/.config/openchamber`). Existing desktop clients and CLIs are reused. Installation is process-local single-flight, needs no global PATH change or desktop environment, and fails explicitly for unsupported platforms or unverifiable downloads.
+The v2 envelope additionally carries recognized plugin API/OAuth accounts and self-contained saved Codex credentials. The source CLI account inventory limits export to recognized providers; hidden and orphaned plugin sign-ins are excluded. Plugin accounts merge by their native account key into `plugin-auth.json` under Magpie's exclusive-create lock, using a private atomic replacement. Destination-only accounts remain; repeated transfers do not append duplicates. Codex uses native `accounts import codex --yes`, which owns account identity/deduplication and the OS-level `logins.json` lock. OpenChamber never writes `logins.json` or copies machine-local account homes. Other subscription formats and accounts discovered only from external clients are not inferred or silently treated as transferred: unsupported active source accounts produce `sign_in_required`. An import re-reads `accounts --json` and requires all transferred plugin account counts and Codex identities to be recognized before returning success. This checks discovery, not successful model inference or future token renewal; revoked credentials still require login.
 
-The `magpie` transfer kind is a bounded, versioned `magpie-sync-v1` binary JSON envelope carrying an encrypted native backup and a random per-transfer passphrase. Both travel only through the authenticated sync transport; Relay adds its existing E2EE. Passphrases go to child stdin, never argv, run logs or disk. Private temporary directories hold only native encrypted backups and are removed on success/failure. Raw child output is kept local and sanitized before reporting. A zero exit with excluded sign-ins or unavailable agent settings is successful restore with `magpieWarnings` (`sign_in_required`, `agent_settings_skipped`), not a failed transfer. Receipts carry these codes through SSH/direct/Relay and desktop IPC to a localized completion warning. Provider/API-key, plugin-install or library-application failures remain errors with a sanitized reason. CLI failure can leave some native configuration applied; already-applied OpenCode files remain too. Retrying can complete the merge; this is not an atomic cross-application rollback.
+Missing destination executables are installed only when Magpie is explicitly selected for import, never in preview or ordinary OpenCode sync. The host selects the official pure CLI asset for macOS/Linux/Windows x64/arm64 from `https://usemagpie.ai/api/latest`, verifies SHA-256, checks `--version`, then atomically publishes it under `<OPENCHAMBER_DATA_DIR>/tools/magpie/` (default `~/.config/openchamber`). Existing desktop clients and CLIs are reused. Installation is process-local single-flight, needs no global PATH change or desktop environment, and fails explicitly for unsupported platforms or unverifiable downloads.
+
+Selected sync also publishes `~/.local/bin/magpie` (`magpie.exe` on Windows), a path searched explicitly by `opencode-magpie-plugin`. POSIX uses a symlink, Windows a hard link for installed-mode data and a symlink for portable data; unsupported linking fails explicitly. Existing valid user commands using the same data directory are retained; conflicting/broken entries are not overwritten. Shared-service and private OpenCode startup repair the command entry for an already managed CLI before launching OpenCode; they never download Magpie just because OpenChamber starts. SSH/direct/Relay push and pull apply Magpie before OpenCode config archives, preventing a newly synced plugin from loading before its dependency is installed. Native agent settings skipped before sign-in are retried after authorization succeeds.
+
+The `magpie` transfer kind exports a bounded `magpie-sync-v2` JSON envelope containing the encrypted native backup, a random per-transfer passphrase and portable authorizations. The envelope is sensitive and stays in memory on authenticated sync transports; Relay adds its existing E2EE. New receivers accept old `magpie-sync-v1` config-only envelopes with the original warning behavior; old receivers reject v2 rather than silently discarding its accounts. Upgrade both hosts for authorization sync. Validate the entire envelope before installation or restore. Passphrases go to child stdin, never argv, run logs or disk. Private temporary directories hold native encrypted backups and, during native Codex import only, a mode-0600 credential file; both are removed on success/failure. Raw child output is sanitized before reporting. A zero exit with genuinely missing/unsupported sign-ins or unavailable agent settings returns `magpieWarnings` (`sign_in_required`, `agent_settings_skipped`). The sign-in warning is recomputed after authorization transfer, not copied from the pre-transfer native restore. Receipts carry these codes through SSH/direct/Relay and desktop IPC to localized completion warnings. Provider/API-key, plugin-install, library, account import and verification failures remain errors. CLI failure can leave configuration and earlier accounts applied; retry merges idempotently. There is no cross-application rollback, and process termination can interrupt cleanup.
 
 `/put/magpie` requires a selected prepared plan and finalize requires its receipt. Standalone `/magpie` is the corresponding authenticated host operation for SSH and local pull. Both use one host-local import/export lock. Desktop main only moves bytes and resolves the local host at call time; the web host owns process execution and installation, including under backend OTA. Web/mobile hosts can receive this operation; the initiating wizard remains desktop-only. No credential values enter previews or sync-run summaries.

package/server/lib/config-sync/engine.js

@@ -65,6 +65,7 @@ export const applyConfigSyncPlan = async ({
 
   await executor.prepare(plan, { syncRunId });
 
+  if (magpiePayload) await executor.putTar({ kind: 'magpie', payload: magpiePayload });
   if (configTarBuffer) {
     await executor.putTar({ kind: 'config', payload: configTarBuffer });
   }
@@ -75,7 +76,6 @@ export const applyConfigSyncPlan = async ({
     // Versioned credential payload; never a database or filesystem archive.
     await executor.putTar({ kind: 'credentials', payload: credentialPayload });
   }
-  if (magpiePayload) await executor.putTar({ kind: 'magpie', payload: magpiePayload });
 
   const receipt = await executor.finalize(plan, { syncRunId });
 

package/server/lib/config-sync/magpie-auth.js

@@ -0,0 +1,111 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { randomBytes } from 'node:crypto';
+import { setTimeout as delay } from 'node:timers/promises';
+
+const MAX_AUTH_BYTES = 8 * 1024 * 1024;
+const object = (value) => value !== null && typeof value === 'object' && !Array.isArray(value);
+const accountKey = (value) => typeof value === 'string' && /^[\w.-]+(?:#[\w.-]+)?$/.test(value)
+  && !['__proto__', 'constructor', 'prototype'].includes(value);
+const portableLogin = (row, plugins) => object(row) && typeof row.user === 'string'
+  && ((row.agent === 'codex' && !row.home && object(row.auth) && object(row.auth.tokens))
+    || (typeof row.agent === 'string' && row.agent.startsWith('plugin:')
+      && accountKey(row.home) && Object.hasOwn(plugins, row.home)
+      && row.agent === `plugin:${row.home.split('#')[0]}`));
+
+const readStore = async (file, fallback) => {
+  try {
+    if ((await fs.stat(file)).size > MAX_AUTH_BYTES) throw new Error();
+    return JSON.parse(await fs.readFile(file, 'utf8'));
+  } catch (error) {
+    if (error.code === 'ENOENT') return fallback;
+    throw new Error('Unable to read Magpie authorization store');
+  }
+};
+
+export const validateMagpieAuth = (value) => {
+  if (!object(value) || !object(value.plugins) || !Array.isArray(value.logins)
+    || typeof value.incomplete !== 'boolean' || JSON.stringify(value).length > MAX_AUTH_BYTES
+    || Object.entries(value.plugins).some(([key, auth]) => !accountKey(key) || !object(auth)
+      || !['api', 'oauth'].includes(auth.type)
+      || (auth.type === 'api' ? typeof auth.key !== 'string' || !auth.key
+        : typeof auth.access !== 'string' || typeof auth.refresh !== 'string'))
+    || value.logins.some((row) => !portableLogin(row, value.plugins))) {
+    throw new Error('Invalid Magpie authorization payload');
+  }
+  return value;
+};
+
+export const collectMagpieAuth = async (dir, accounts) => {
+  if (!Array.isArray(accounts) || accounts.some((row) => !object(row) || typeof row.agent !== 'string')) {
+    throw new Error('Unable to read source Magpie accounts');
+  }
+  const plugins = await readStore(path.join(dir, 'plugin-auth.json'), {});
+  const rows = await readStore(path.join(dir, 'logins.json'), []);
+  if (!object(plugins) || !Array.isArray(rows) || rows.some((row) => !object(row))) {
+    throw new Error('Invalid Magpie authorization store');
+  }
+  const available = new Set(accounts.map((row) => row.agent));
+  const visiblePlugins = Object.fromEntries(Object.entries(plugins).filter(([key]) => available.has(key.split('#')[0])
+    && !rows.some((row) => row.agent === `plugin:${key.split('#')[0]}` && row.home === key && row.hidden)));
+  const logins = rows.filter((row) => !row.hidden && portableLogin(row, visiblePlugins));
+  return validateMagpieAuth({ plugins: visiblePlugins, logins,
+    incomplete: accounts.some((account) => !Object.keys(visiblePlugins).some((key) => key.split('#')[0] === account.agent)
+      && !logins.some((row) => row.agent === account.agent && row.user === account.user)) });
+};
+
+const writeStore = async (file, value) => {
+  const staging = `${file}.${randomBytes(8).toString('hex')}.tmp`;
+  try {
+    await fs.writeFile(staging, JSON.stringify(value), { mode: 0o600, flag: 'wx' });
+    await fs.rename(staging, file);
+  } finally { await fs.rm(staging, { force: true }); }
+};
+
+// Use Magpie's own lock filenames; never steal a lock from a running token refresh.
+const lockStore = async (file) => {
+  for (let attempt = 0; attempt < 100; attempt++) {
+    try {
+      const handle = await fs.open(`${file}.lock`, 'wx', 0o600);
+      await handle.close();
+      return () => fs.rm(`${file}.lock`, { force: true });
+    } catch (error) {
+      if (error.code !== 'EEXIST') throw new Error('Unable to lock Magpie authorization store');
+      await delay(50);
+    }
+  }
+  throw new Error('Magpie authorization store is busy; retry sync');
+};
+
+export const restoreMagpieAuth = async (dir, input, importCodex) => {
+  const auth = validateMagpieAuth(input);
+  await fs.mkdir(dir, { recursive: true, mode: 0o700 });
+  const pluginFile = path.join(dir, 'plugin-auth.json');
+  const unlockPlugins = await lockStore(pluginFile);
+  try {
+    const plugins = await readStore(pluginFile, {});
+    if (!object(plugins)) throw new Error('Invalid destination Magpie authorization store');
+    await writeStore(pluginFile, { ...plugins, ...auth.plugins });
+  } finally { await unlockPlugins(); }
+  // Codex's native importer owns its OS-level logins lock, account deduplication and identity.
+  for (const row of auth.logins) {
+    if (row.agent === 'codex' && !row.hidden) await importCodex(row.auth);
+  }
+};
+
+export const verifyMagpieAuth = (auth, accounts) => {
+  if (!Array.isArray(accounts) || accounts.some((row) => !object(row) || typeof row.agent !== 'string')) {
+    throw new Error('Unable to verify Magpie accounts');
+  }
+  const expected = new Map();
+  for (const key of Object.keys(auth.plugins)) {
+    const id = key.split('#')[0];
+    expected.set(id, (expected.get(id) || 0) + 1);
+  }
+  const missingAccount = auth.logins.some((row) => !row.hidden
+    && !accounts.some((account) => account.agent === row.agent.replace(/^plugin:/, '')
+      && String(account.user).toLowerCase() === row.user.toLowerCase()));
+  if (missingAccount || [...expected].some(([id, count]) => accounts.filter((row) => row.agent === id).length < count)) {
+    throw new Error('Magpie authorization saved but some accounts are not recognized; check destination plugins and retry');
+  }
+};

package/server/lib/config-sync/magpie-auth.test.js

@@ -0,0 +1,79 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { collectMagpieAuth, restoreMagpieAuth, validateMagpieAuth, verifyMagpieAuth } from './magpie-auth.js';
+
+const dirs = [];
+const directory = async () => {
+  const dir = await fs.mkdtemp(path.join(os.tmpdir(), 'magpie-auth-test-'));
+  dirs.push(dir);
+  return dir;
+};
+const auth = { plugins: { 'cursor#one': { type: 'oauth', access: 'fixture-access', refresh: 'fixture-refresh', expires: 123 } }, logins: [], incomplete: false };
+afterEach(async () => { vi.restoreAllMocks(); await Promise.all(dirs.splice(0).map((dir) => fs.rm(dir, { recursive: true, force: true }))); });
+
+describe('Magpie authorization transfer', () => {
+  it('exports recognized plugin accounts, excludes hidden/stale accounts and flags unsupported subscriptions', async () => {
+    const dir = await directory();
+    await fs.writeFile(path.join(dir, 'plugin-auth.json'), JSON.stringify({ ...auth.plugins,
+      stale: { type: 'api', key: 'fixture' }, 'cursor#hidden': { type: 'api', key: 'fixture' } }));
+    await fs.writeFile(path.join(dir, 'logins.json'), JSON.stringify([
+      { agent: 'plugin:cursor', user: 'hidden', home: 'cursor#hidden', hidden: 'mark' },
+      { agent: 'chatgpt-api', user: 'fixture', auth: { clientId: 'machine-specific' } },
+    ]));
+    const result = await collectMagpieAuth(dir, [{ agent: 'cursor' }, { agent: 'chatgpt-api', user: 'fixture' }]);
+    expect(result.plugins).toEqual(auth.plugins);
+    expect(result.logins).toEqual([]);
+    expect(result.incomplete).toBe(true);
+  });
+
+  it('does not turn corrupted stores into successful empty credentials', async () => {
+    const dir = await directory();
+    await fs.writeFile(path.join(dir, 'plugin-auth.json'), '{broken');
+    await expect(collectMagpieAuth(dir, [])).rejects.toThrow('authorization store');
+    await expect(restoreMagpieAuth(dir, auth, vi.fn())).rejects.toThrow('authorization store');
+    expect(await fs.readFile(path.join(dir, 'plugin-auth.json'), 'utf8')).toBe('{broken');
+    expect(await fs.readdir(dir)).toEqual(['plugin-auth.json']);
+  });
+
+  it('merges repeated imports without deleting unrelated accounts and releases the plugin lock before native imports', async () => {
+    const dir = await directory();
+    await fs.writeFile(path.join(dir, 'plugin-auth.json'), '{"other":{"type":"api","key":"keep"}}');
+    const input = { ...auth, logins: [{ agent: 'codex', user: 'fixture', auth: { tokens: {} } }] };
+    const importCodex = vi.fn(async () => {
+      await expect(fs.stat(path.join(dir, 'plugin-auth.json.lock'))).rejects.toThrow();
+    });
+    await restoreMagpieAuth(dir, input, importCodex);
+    await restoreMagpieAuth(dir, input, importCodex);
+    expect(JSON.parse(await fs.readFile(path.join(dir, 'plugin-auth.json'), 'utf8'))).toEqual({ other: { type: 'api', key: 'keep' }, ...auth.plugins });
+    expect((await fs.stat(path.join(dir, 'plugin-auth.json'))).mode & 0o777).toBe(0o600);
+    expect(await fs.readdir(dir)).toEqual(['plugin-auth.json']);
+  });
+
+  it('keeps successful plugin writes when a native import fails, so retry can finish', async () => {
+    const dir = await directory();
+    await expect(restoreMagpieAuth(dir, { ...auth, logins: [{ agent: 'codex', user: 'fixture', auth: { tokens: {} } }] },
+      async () => { throw new Error('fixture failure'); })).rejects.toThrow();
+    expect(JSON.parse(await fs.readFile(path.join(dir, 'plugin-auth.json'), 'utf8'))).toEqual(auth.plugins);
+    expect(await fs.readdir(dir)).toEqual(['plugin-auth.json']);
+  });
+
+  it('preserves the previous store and cleans staging files when atomic publication fails', async () => {
+    const dir = await directory();
+    const file = path.join(dir, 'plugin-auth.json');
+    await fs.writeFile(file, '{"other":{"type":"api","key":"keep"}}');
+    vi.spyOn(fs, 'rename').mockRejectedValueOnce(new Error('fixture rename failure'));
+    await expect(restoreMagpieAuth(dir, auth, vi.fn())).rejects.toThrow();
+    expect(JSON.parse(await fs.readFile(file, 'utf8'))).toEqual({ other: { type: 'api', key: 'keep' } });
+    expect(await fs.readdir(dir)).toEqual(['plugin-auth.json']);
+  });
+
+  it('rejects unsafe shapes and verifies every expected account rather than one account per provider', () => {
+    expect(() => validateMagpieAuth({ ...auth, plugins: { '../path': { type: 'api', key: 'fixture' } } })).toThrow();
+    const two = { ...auth, plugins: { ...auth.plugins, 'cursor#two': auth.plugins['cursor#one'] } };
+    expect(() => verifyMagpieAuth(two, [{ agent: 'cursor' }])).toThrow('not recognized');
+    expect(() => verifyMagpieAuth(two, [{ agent: 'cursor' }, { agent: 'cursor' }])).not.toThrow();
+    expect(() => verifyMagpieAuth(auth, {})).toThrow('verify');
+  });
+});

package/server/lib/config-sync/magpie.js

@@ -3,9 +3,10 @@ import os from 'node:os';
 import path from 'node:path';
 import { spawn } from 'node:child_process';
 import { createHash, randomBytes } from 'node:crypto';
+import { collectMagpieAuth, restoreMagpieAuth, validateMagpieAuth, verifyMagpieAuth } from './magpie-auth.js';
 
 const MAX_BYTES = 64 * 1024 * 1024;
-const CONFIG_FILES = ['providers.json', 'settings.json', 'profiles.json', 'library.json', 'plugins.json'];
+const CONFIG_FILES = ['providers.json', 'settings.json', 'profiles.json', 'library.json', 'plugins.json', 'plugin-auth.json', 'logins.json'];
 const exists = async (file) => {
   try { return await fs.stat(file); }
   catch (error) { if (error.code === 'ENOENT' || error.code === 'ENOTDIR') return null; throw error; }
@@ -103,7 +104,7 @@ export function createMagpieSync({
 
   const inventory = async () => {
     const binary = await locate();
-    return { available: await hasConfig(await dataDir(binary)), installed: Boolean(binary) };
+    return { available: Boolean(binary) && await hasConfig(await dataDir(binary)), installed: Boolean(binary) };
   };
 
   const downloadBytes = async (url, limit) => {
@@ -119,9 +120,38 @@ export function createMagpieSync({
     return Buffer.concat(chunks);
   };
 
+  const publishExecutable = async (binary) => {
+    const entry = path.join(home(), '.local', 'bin', platform === 'win32' ? 'magpie.exe' : 'magpie');
+    if (await exists(entry)) {
+      if (await fs.realpath(entry) === binary) return binary;
+      const version = await run(entry, ['--version'], { env, timeout: 10_000 });
+      if (!/^magpie\s+\S+/m.test(version)) throw new Error('Magpie command conflicts with an existing executable');
+      if (await dataDir(await fs.realpath(entry)) !== await dataDir(binary)) {
+        throw new Error('Magpie command uses a different portable configuration; resolve the command conflict before syncing');
+      }
+      return binary;
+    }
+    await fs.mkdir(path.dirname(entry), { recursive: true });
+    try {
+      if (platform === 'win32' && await dataDir(binary) === configDir()) await fs.link(binary, entry);
+      else await fs.symlink(binary, entry, 'file');
+    } catch (error) {
+      if (error.code !== 'EEXIST' || !await exists(entry)) throw new Error('Unable to publish Magpie command for plugins');
+    }
+    return binary;
+  };
+
+  const repairInstallation = async () => {
+    const binary = managedBinary();
+    if (!(await exists(binary))?.isFile()) return;
+    const version = await run(binary, ['--version'], { env, timeout: 10_000 });
+    if (!/^magpie\s+\S+/m.test(version)) throw new Error('Invalid managed Magpie executable');
+    await publishExecutable(await fs.realpath(binary));
+  };
+
   const ensure = async () => {
     const binary = await locate();
-    if (binary) return binary;
+    if (binary) return publishExecutable(binary);
     if (installing) return installing;
     installing = (async () => {
       const cpu = { x64: 'amd64', arm64: 'arm64' }[arch];
@@ -146,7 +176,7 @@ export function createMagpieSync({
         if (!/^magpie\s+\S+/m.test(version)) throw new Error('Invalid downloaded Magpie CLI');
         await fs.rename(staging, target);
       } finally { await fs.rm(staging, { force: true }); }
-      return target;
+      return publishExecutable(target);
     })();
     try { return await installing; }
     finally { installing = null; }
@@ -165,6 +195,7 @@ export function createMagpieSync({
 
   return {
     inventory,
+    repairInstallation,
     download: () => exclusive(async () => {
       if (!(await inventory()).available) throw new Error('No Magpie configuration found on source');
       const binary = await ensure();
@@ -174,7 +205,14 @@ export function createMagpieSync({
         const stat = await fs.stat(file);
         if (stat.size > MAX_BYTES) throw new Error('Magpie backup exceeds size limit');
         const backup = await fs.readFile(file);
-        return Buffer.from(JSON.stringify({ format: 'magpie-sync-v1', passphrase, backup: backup.toString('base64') }));
+        let authorization;
+        try {
+          const accounts = JSON.parse(await run(binary, ['accounts', '--json'], { env }));
+          authorization = await collectMagpieAuth(await dataDir(binary), accounts);
+        } catch { throw new Error('Unable to export Magpie authorizations'); }
+        const payload = Buffer.from(JSON.stringify({ format: 'magpie-sync-v2', passphrase, backup: backup.toString('base64'), authorization }));
+        if (payload.length > MAX_BYTES * 2) throw new Error('Magpie sync exceeds size limit');
+        return payload;
       });
     }),
     import: (payload) => exclusive(async () => {
@@ -183,8 +221,9 @@ export function createMagpieSync({
       try {
         if (payload.length > MAX_BYTES * 2) throw new Error();
         decoded = JSON.parse(Buffer.from(payload).toString());
-        if (decoded.format !== 'magpie-sync-v1' || !/^[a-f0-9]{64}$/.test(decoded.passphrase)
+        if (!['magpie-sync-v1', 'magpie-sync-v2'].includes(decoded.format) || !/^[a-f0-9]{64}$/.test(decoded.passphrase)
           || typeof decoded.backup !== 'string') throw new Error();
+        if (decoded.format === 'magpie-sync-v2') validateMagpieAuth(decoded.authorization);
         backup = Buffer.from(decoded.backup, 'base64');
         if (!backup.length || backup.length > MAX_BYTES || JSON.parse(backup.toString()).format !== 'magpie-backup') throw new Error();
       } catch { throw new Error('Invalid Magpie sync payload'); }
@@ -197,8 +236,38 @@ export function createMagpieSync({
         if (/Couldn't add the plugin/i.test(output)) throw new Error('Magpie restore partially completed: plugin installation failed. Check the target Magpie plugins.');
         if (/Library:.*couldn't/i.test(output)) throw new Error('Magpie restore partially completed: library application failed. Check the target Magpie library.');
         if (/Needs a key/i.test(output)) throw new Error('Magpie restore partially completed: some providers still require API keys.');
+        let needsSignIn = /not signed in on this computer/i.test(output);
+        if (decoded.format === 'magpie-sync-v2') {
+          const dir = await dataDir(binary);
+          try {
+            await restoreMagpieAuth(dir, decoded.authorization, async (auth) => {
+              const credentialFile = path.join(path.dirname(file), 'codex.json');
+              try {
+                await fs.writeFile(credentialFile, JSON.stringify(auth), { mode: 0o600, flag: 'wx' });
+                await run(binary, ['accounts', 'import', 'codex', credentialFile, '--yes'], { env });
+              } finally { await fs.rm(credentialFile, { force: true }); }
+            });
+            const accounts = JSON.parse(await run(binary, ['accounts', '--json'], { env }));
+            verifyMagpieAuth(decoded.authorization, accounts);
+            const configured = JSON.parse(await fs.readFile(path.join(dir, 'providers.json'), 'utf8').catch((error) => {
+              if (error.code === 'ENOENT') return '{"providers":[]}';
+              throw error;
+            }));
+            if (!Array.isArray(configured.providers)) throw new Error();
+            const signedIn = new Set(accounts.map((account) => account.agent));
+            needsSignIn = decoded.authorization.incomplete || configured.providers.some((provider) =>
+              !provider.hidden && provider.id && !['chat', 'responses', 'anthropic', 'gemini'].some((key) => provider[key])
+              && !signedIn.has(provider.id));
+            if (/Left as they are/i.test(output)) {
+              output = await run(binary, ['restore', file], { env, input: `${decoded.passphrase}\n` });
+              if (/Couldn't add the plugin|Needs a key|Library:.*couldn't/i.test(output)) throw new Error();
+            }
+          } catch {
+            throw new Error('Magpie authorization sync or verification failed; some configuration and accounts may already be applied. Retry to finish.');
+          }
+        }
         const magpieWarnings = [];
-        if (/not signed in on this computer/i.test(output)) magpieWarnings.push('sign_in_required');
+        if (needsSignIn) magpieWarnings.push('sign_in_required');
         if (/Left as they are/i.test(output)) magpieWarnings.push('agent_settings_skipped');
         return { ok: true, ...(magpieWarnings.length ? { magpieWarnings } : {}) };
       });

package/server/lib/config-sync/magpie.test.js

@@ -23,13 +23,13 @@ const write = async (file, content = '{}') => {
 afterEach(async () => { await Promise.all(dirs.splice(0).map((dir) => fs.rm(dir, { recursive: true, force: true }))); });
 
 describe('Magpie discovery and native transfer', () => {
-  it('discovers config-only sources through XDG without installing during preview', async () => {
+  it('hides config-only sources until Magpie is installed, without installing during preview', async () => {
     const { home, options } = await machine();
     const fetchImpl = vi.fn();
     const sync = createMagpieSync({ ...options, fetchImpl });
     expect(await sync.inventory()).toEqual({ available: false, installed: false });
     await write(path.join(home, '.config', 'magpie', 'providers.json'));
-    expect(await sync.inventory()).toEqual({ available: true, installed: false });
+    expect(await sync.inventory()).toEqual({ available: false, installed: false });
     expect(fetchImpl).not.toHaveBeenCalled();
   });
 
@@ -55,6 +55,7 @@ describe('Magpie discovery and native transfer', () => {
     await write(path.join(source.home, '.config', 'magpie', 'providers.json'));
     const runSource = vi.fn(async (_binary, args, ctx) => {
       if (args[0] === '--version') return 'magpie 0.1.0';
+      if (args[0] === 'accounts') return '[]';
       expect(args[0]).toBe('backup');
       expect(ctx.input).toMatch(/^[a-f0-9]{64}\n$/);
       expect(args).not.toContain(ctx.input.trim());
@@ -70,14 +71,17 @@ describe('Magpie discovery and native transfer', () => {
       } } }) : new Response(bytes));
     const runTarget = vi.fn(async (_binary, args, ctx) => {
       if (args[0] === '--version') return 'magpie 0.1.0';
+      if (args[0] === 'accounts') return '[]';
       expect(args[0]).toBe('restore');
       expect(ctx.input.trim()).toBe(JSON.parse(payload).passphrase);
       expect(JSON.parse(await fs.readFile(args[1], 'utf8')).format).toBe('magpie-backup');
+      await write(path.join(target.home, '.config', 'magpie', 'providers.json'), '{"providers":[]}');
       return 'restored';
     });
     const destination = createMagpieSync({ ...target.options, fetchImpl, run: runTarget });
     await expect(destination.import(payload)).resolves.toEqual({ ok: true });
     expect(fetchImpl).toHaveBeenCalledTimes(2);
+    expect(await fs.realpath(path.join(target.home, '.local/bin/magpie'))).toBe(await fs.realpath(path.join(target.home, '.config/openchamber/tools/magpie/magpie')));
     await expect(destination.import(payload)).resolves.toEqual({ ok: true });
     expect(fetchImpl).toHaveBeenCalledTimes(2);
     for (const item of [source, target]) {
@@ -85,6 +89,98 @@ describe('Magpie discovery and native transfer', () => {
     }
   });
 
+  it('repairs a previously managed installation without downloading or overwriting a user command', async () => {
+    const { home, options } = await machine();
+    const managed = path.join(home, '.config/openchamber/tools/magpie/magpie');
+    const entry = path.join(home, '.local/bin/magpie');
+    const fetchImpl = vi.fn();
+    const run = vi.fn(async () => 'magpie 0.1.1319');
+    const sync = createMagpieSync({ ...options, fetchImpl, run });
+    await sync.repairInstallation();
+    expect(run).not.toHaveBeenCalled();
+    await write(managed, 'fixture');
+    await sync.repairInstallation();
+    await sync.repairInstallation();
+    expect(await fs.realpath(entry)).toBe(await fs.realpath(managed));
+    await fs.unlink(entry);
+    await write(entry, 'user installation');
+    await sync.repairInstallation();
+    expect(await fs.readFile(entry, 'utf8')).toBe('user installation');
+    expect(fetchImpl).not.toHaveBeenCalled();
+  });
+
+  it('round-trips plugin accounts and Codex through v2 and verifies the final account inventory', async () => {
+    const source = await machine();
+    const target = await machine();
+    for (const item of [source, target]) await write(path.join(item.home, '.local/bin/magpie'), 'fixture');
+    const sourceDir = path.join(source.home, '.config/magpie');
+    const targetDir = path.join(target.home, '.config/magpie');
+    await write(path.join(sourceDir, 'providers.json'), '{"providers":[{"id":"astra"},{"id":"codex"}]}');
+    await write(path.join(sourceDir, 'plugin-auth.json'), JSON.stringify({ 'astra#one': { type: 'api', key: 'fixture-key' } }));
+    await write(path.join(sourceDir, 'logins.json'), JSON.stringify([
+      { agent: 'codex', user: 'fixture@example.invalid', auth: { tokens: { access_token: 'fixture-token' } } },
+    ]));
+    const payload = await createMagpieSync({ ...source.options, run: async (_binary, args) => {
+      if (args[0] === '--version') return 'magpie 0.1.1319';
+      if (args[0] === 'accounts') return '[{"agent":"astra"},{"agent":"codex","user":"fixture@example.invalid"}]';
+      await write(args[1], '{"format":"magpie-backup"}');
+      return '';
+    } }).download();
+    expect(JSON.parse(payload).format).toBe('magpie-sync-v2');
+    await write(path.join(targetDir, 'plugin-auth.json'), '{"destination-only":{"type":"api","key":"keep"}}');
+    let recognized = true;
+    const run = vi.fn(async (_binary, args) => {
+      if (args[0] === '--version') return 'magpie 0.1.1319';
+      if (args[0] === 'restore') {
+        await write(path.join(targetDir, 'providers.json'), await fs.readFile(path.join(sourceDir, 'providers.json')));
+        return 'not signed in on this computer';
+      }
+      if (args[1] === 'import') {
+        expect(args).not.toContain('fixture-token');
+        expect(JSON.parse(await fs.readFile(args[3], 'utf8')).tokens.access_token).toBe('fixture-token');
+        expect((await fs.stat(args[3])).mode & 0o777).toBe(0o600);
+        return '';
+      }
+      return JSON.stringify(recognized ? [{ agent: 'astra' }, { agent: 'codex', user: 'fixture@example.invalid' }] : []);
+    });
+    const sync = createMagpieSync({ ...target.options, run });
+    await expect(sync.import(payload)).resolves.toEqual({ ok: true });
+    await expect(sync.import(payload)).resolves.toEqual({ ok: true });
+    const stored = JSON.parse(await fs.readFile(path.join(targetDir, 'plugin-auth.json'), 'utf8'));
+    expect(Object.keys(stored)).toEqual(['destination-only', 'astra#one']);
+    recognized = false;
+    await expect(sync.import(payload)).rejects.toThrow('authorization sync or verification failed');
+    expect((await fs.readdir(target.home)).filter((name) => name.startsWith('openchamber-magpie-'))).toEqual([]);
+  });
+
+  it('rejects malformed v2 authorization before installing or restoring', async () => {
+    const { options } = await machine();
+    const run = vi.fn();
+    const fetchImpl = vi.fn();
+    const payload = Buffer.from(JSON.stringify({ format: 'magpie-sync-v2', passphrase: 'a'.repeat(64),
+      backup: Buffer.from('{"format":"magpie-backup"}').toString('base64'),
+      authorization: { plugins: {}, logins: [{ agent: 'codex', home: '/source/path', auth: {} }], incomplete: false } }));
+    await expect(createMagpieSync({ ...options, run, fetchImpl }).import(payload)).rejects.toThrow('Invalid Magpie sync payload');
+    expect(run).not.toHaveBeenCalled();
+    expect(fetchImpl).not.toHaveBeenCalled();
+  });
+
+  it('retries agent settings after authorizations instead of keeping a pre-login skip warning', async () => {
+    const { home, options } = await machine();
+    await write(path.join(home, '.local/bin/magpie'), 'fixture');
+    let restores = 0;
+    const run = async (_binary, args) => {
+      if (args[0] === '--version') return 'magpie 0.1.1319';
+      if (args[0] === 'accounts') return '[]';
+      return ++restores === 1 ? 'Left as they are' : 'restored';
+    };
+    const payload = Buffer.from(JSON.stringify({ format: 'magpie-sync-v2', passphrase: 'a'.repeat(64),
+      backup: Buffer.from('{"format":"magpie-backup"}').toString('base64'),
+      authorization: { plugins: {}, logins: [], incomplete: false } }));
+    await expect(createMagpieSync({ ...options, run }).import(payload)).resolves.toEqual({ ok: true });
+    expect(restores).toBe(2);
+  });
+
   it('does not install on malformed payload and refuses partial restore without leaking CLI output', async () => {
     const { home, options } = await machine();
     const fetchImpl = vi.fn();
@@ -123,6 +219,10 @@ describe('Magpie discovery and native transfer', () => {
     const result = await applyConfigSyncPlan({ plan, executor, syncRunId: 'test', sourceHomedir: home, collectMagpie: async () => Buffer.from('fixture') });
     expect(result.magpieWarnings).toEqual(['sign_in_required']);
     expect(received).toEqual([{ kind: 'magpie', payload: Buffer.from('fixture') }]);
+    received.length = 0;
+    await applyConfigSyncPlan({ plan: { ...plan, files: [{ path: 'opencode.json' }] }, executor, syncRunId: 'ordered', sourceHomedir: home,
+      collectTar: async () => Buffer.from('config'), collectMagpie: async () => Buffer.from('fixture') });
+    expect(received.map((entry) => entry.kind)).toEqual(['magpie', 'config']);
     const pull = planOpenCodeConfigSyncFromInventory({ files: [], directories: [], magpie: { available: true } }, { selections });
     expect(pull.magpieAvailable).toBe(true);
     expect(pull.magpie).toEqual({ bytes: 0 });