@palmyr/cli 1.4.0 → 1.5.4

package/dist/cli.js

@@ -17,7 +17,7 @@ import { render as inkRender } from 'ink';
 import { ConfigScreen, Dashboard, DoctorScreen, DomainCheckScreen, DomainPricingScreen, ErrorScreen, HealthScreen, MenuScreen, PricingScreen, RecordsScreen, SetupScreen, StatusScreen, SuccessScreen, WalletCreateScreen, WalletStatusScreen, WalletListScreen } from './app.js';
 import { Palmyr } from './sdk.js';
 import { loadConfig, saveConfig, ensureDirs, log, addPhone, addDomain, addNote } from './config.js';
-import { theme as t, icon, Spinner, table, kv, section, setAgentMode as setUiAgentMode } from './ui.js';
+import { theme as t, icon, Spinner, warn, table, kv, section, setAgentMode as setUiAgentMode } from './ui.js';
 import { existsSync, readFileSync } from 'fs';
 import { homedir } from 'os';
 import { fileURLToPath } from 'url';
@@ -1462,9 +1462,11 @@ async function main() {
                             { name: 'check', description: 'Check availability', hint: '--name example.dev' },
                             { name: 'pricing', description: 'Get TLD pricing', hint: '--name example' },
                             { name: 'buy', description: 'Register a domain', hint: '--name example.dev' },
-                            { name: 'list', description: 'List domains owned by your wallet', hint: '' },
+                            { name: 'list', description: 'List domains owned or shared with your wallet', hint: '' },
                             { name: 'dns', description: 'Get DNS records', hint: '--name example.dev' },
                             { name: 'transfer-ownership', description: 'Transfer domain to another wallet', hint: '--name example.dev --to <wallet>' },
+                            { name: 'share', description: 'Grant another wallet shared access', hint: '--name example.dev --with <wallet>' },
+                            { name: 'unshare', description: 'Revoke a wallet’s shared access', hint: '--name example.dev --from <wallet>' },
                         ],
                         fromHome,
                     });
@@ -1582,6 +1584,28 @@ async function main() {
                         const data = await ao.domainTransferOwnership(name, to);
                         return print(data);
                     }
+                    case 'share': {
+                        const name = flags.name || positional[0];
+                        const withWallet = flags.with || flags.wallet;
+                        if (!name)
+                            err('--name domain.dev required');
+                        if (!withWallet)
+                            err('--with <wallet> required');
+                        const data = await ao.domainShare(name, withWallet);
+                        log(`domain share: ${name} → ${withWallet}`);
+                        return print(data);
+                    }
+                    case 'unshare': {
+                        const name = flags.name || positional[0];
+                        const targetWallet = flags.from || flags.wallet;
+                        if (!name)
+                            err('--name domain.dev required');
+                        if (!targetWallet)
+                            err('--from <wallet> required');
+                        const data = await ao.domainUnshare(name, targetWallet);
+                        log(`domain unshare: ${name} ✗ ${targetWallet}`);
+                        return print(data);
+                    }
                     case 'dns': {
                         const name = flags.name || positional[0];
                         if (!name)
@@ -1600,7 +1624,7 @@ async function main() {
                         }));
                         break;
                     }
-                    default: err(`Unknown domain command: ${subcommand}. Try: check, pricing, buy, list, dns, transfer-ownership`);
+                    default: err(`Unknown domain command: ${subcommand}. Try: check, pricing, buy, list, dns, transfer-ownership, share, unshare`);
                 }
                 break;
             }
@@ -3976,6 +4000,75 @@ async function main() {
             case 'twitter': {
                 const sv = await import('./social-vault.js');
                 const platform = 'twitter';
+                // Resolve a username to its server-side account_id and which table
+                // holds it. X accounts can live in two places: x_accounts (pool-bought)
+                // and social_registered_accounts (BYO-registered). The local vault
+                // doesn't track which, so we query both in parallel and find a match.
+                // Used by transfer / share / unshare to dispatch to the correct
+                // endpoint family. Returns null if the username isn't on the server.
+                const resolveServerAccount = async (username) => {
+                    const [xMine, reg] = await Promise.allSettled([
+                        ao.xAccountsMine(),
+                        ao.socialTwitterListRegistered(),
+                    ]);
+                    if (xMine.status === 'fulfilled') {
+                        const m = (xMine.value?.accounts || []).find((a) => a.username === username);
+                        if (m)
+                            return { kind: 'x_accounts', id: m.id };
+                    }
+                    if (reg.status === 'fulfilled') {
+                        const m = (reg.value?.accounts || []).find((a) => a.username === username);
+                        if (m)
+                            return { kind: 'registered', id: m.id };
+                    }
+                    return null;
+                };
+                // Look up an account by username; if it's not in the local vault,
+                // check both server-side tables and auto-import any match. This is
+                // what makes `palmyr twitter <op> @h` "just work" for a wallet that
+                // was just transferred or shared an account — no separate `claim`
+                // step. Errs cleanly if the account is neither local nor accessible
+                // server-side. Each auto-import costs ~$0.0011 (two paid lookups +
+                // creds-decryption fee on the registered side), so call sites that
+                // are pure local ops (rename, remove) intentionally skip this.
+                const ensureLocalAccount = async (username) => {
+                    const existing = sv.getAccount(platform, username);
+                    if (existing)
+                        return existing;
+                    const [xRes, regRes] = await Promise.allSettled([
+                        ao.xAccountsMine(),
+                        ao.socialTwitterRegisteredMine(),
+                    ]);
+                    const xMatch = xRes.status === 'fulfilled'
+                        ? (xRes.value?.accounts || []).find((a) => a.username === username)
+                        : null;
+                    const regMatch = regRes.status === 'fulfilled'
+                        ? (regRes.value?.accounts || []).find((a) => a.username === username)
+                        : null;
+                    const match = xMatch || regMatch;
+                    if (!match) {
+                        err(`twitter account "${username}" not found locally or on the server (this wallet has no access)`, EXIT.NOT_FOUND);
+                    }
+                    const cookies = (match.cookies || []);
+                    const ct0 = cookies.find((c) => c.name === 'ct0')?.value;
+                    // Registered accounts return creds nested under `credentials`;
+                    // pool accounts return them flat alongside cookies.
+                    const creds = regMatch
+                        ? regMatch.credentials
+                        : {
+                            login: match.email || match.username,
+                            password: match.password,
+                            email: match.email,
+                            auth_token: match.auth_token || undefined,
+                            ct0,
+                        };
+                    const summary = sv.importAccount(platform, username, creds, { source: 'auto-claim' });
+                    if (cookies.length > 0) {
+                        sv.saveSession(summary.id, platform, cookies);
+                    }
+                    log(`auto-imported @${username} from server (${regMatch ? 'registered' : 'pool'} → local vault)`);
+                    return summary;
+                };
                 if (!subcommand) {
                     showMenu({
                         command: 'twitter',
@@ -3984,7 +4077,7 @@ async function main() {
                         footerLeft: 'Phase 1: local vault + BYO import works today. Server-dependent commands stub out.',
                         commands: [
                             { name: 'import', description: 'Save a BYO account to the local vault', hint: '--username --password --totp-seed' },
-                            { name: 'list', description: 'List all local X accounts' },
+                            { name: 'list', description: 'List local accounts and any server-only ones the wallet can access', hint: '[--local]' },
                             { name: 'info', description: 'Show one account', hint: '<username>' },
                             { name: 'rename', description: 'Update the local record when the handle changes', hint: '<old> --to <new>' },
                             { name: 'remove', description: 'Delete an account from the local vault', hint: '<username> --confirm' },
@@ -3993,6 +4086,10 @@ async function main() {
                             { name: 'login', description: 'Force a fresh server-side session (requires browser runtime)', hint: '<username>' },
                             { name: 'post', description: 'Post a tweet (requires server browser runtime)', hint: '<username> --body "..."' },
                             { name: 'status', description: 'Check if the account is alive / shadow-banned', hint: '<username>' },
+                            { name: 'transfer', description: 'Hand an account to another wallet (rotates password; auto-registers if needed)', hint: '<username> --to <wallet> --confirm' },
+                            { name: 'share', description: 'Grant another wallet shared access', hint: '<username> --with <wallet>' },
+                            { name: 'unshare', description: 'Revoke a wallet’s shared access', hint: '<username> --from <wallet> [--rotate]' },
+                            { name: 'claim', description: 'Import server-side accounts owned by your wallet into the local vault' },
                         ],
                         fromHome,
                     });
@@ -4064,16 +4161,59 @@ async function main() {
                         return print({ ...summary, has_cookies: !!authToken });
                     }
                     case 'list': {
-                        const accounts = sv.listAccounts(platform);
-                        return print({ accounts, count: accounts.length });
+                        // Local vault is always queried (free, instant). By default we
+                        // also query the server for accounts the wallet owns or has been
+                        // shared with — that's how a wallet that just received a transfer
+                        // sees the account here without an extra `claim` step. Pass
+                        // --local to skip the server check for cheap mode.
+                        const localAccounts = sv.listAccounts(platform);
+                        const skipRemote = !!flags.local;
+                        if (skipRemote) {
+                            return print({ accounts: localAccounts, count: localAccounts.length, source: 'local' });
+                        }
+                        const [xRes, regRes] = await Promise.allSettled([
+                            ao.xAccountsMine(),
+                            ao.socialTwitterRegisteredMine(),
+                        ]);
+                        const xAccounts = xRes.status === 'fulfilled' ? (xRes.value?.accounts || []) : [];
+                        const regAccounts = regRes.status === 'fulfilled' ? (regRes.value?.accounts || []) : [];
+                        const localUsernames = new Set(localAccounts.map(a => a.username));
+                        const serverOnly = [];
+                        for (const a of xAccounts) {
+                            if (a.username && !localUsernames.has(a.username)) {
+                                serverOnly.push({
+                                    username: a.username,
+                                    access: a.access || 'owner',
+                                    source_table: 'x_accounts',
+                                    status: 'server-only — run `palmyr twitter claim` to import',
+                                });
+                            }
+                        }
+                        for (const a of regAccounts) {
+                            if (a.username && !localUsernames.has(a.username)) {
+                                serverOnly.push({
+                                    username: a.username,
+                                    access: a.access || 'owner',
+                                    source_table: 'registered',
+                                    status: 'server-only — run `palmyr twitter claim` to import',
+                                });
+                            }
+                        }
+                        return print({
+                            accounts: localAccounts,
+                            server_only: serverOnly,
+                            count_local: localAccounts.length,
+                            count_server_only: serverOnly.length,
+                            ...(serverOnly.length > 0
+                                ? { hint: `${serverOnly.length} account${serverOnly.length === 1 ? '' : 's'} on server but not in local vault — run 'palmyr twitter claim' to import` }
+                                : {}),
+                        });
                     }
                     case 'info': {
                         const username = positional[0] || flags.username;
                         if (!username)
                             err('<username> required');
-                        const acc = sv.getAccount(platform, username);
-                        if (!acc)
-                            err(`twitter account "${username}" not found locally`, EXIT.NOT_FOUND);
+                        const acc = await ensureLocalAccount(username);
                         return print(acc);
                     }
                     case 'rename': {
@@ -4104,6 +4244,7 @@ async function main() {
                         const username = positional[0] || flags.username;
                         if (!username)
                             err('<username> required');
+                        await ensureLocalAccount(username);
                         const creds = sv.unlockCredentials(platform, username);
                         if (!creds.totp_seed)
                             err(`twitter account "${username}" has no TOTP seed configured`, EXIT.NOT_FOUND);
@@ -4207,9 +4348,7 @@ async function main() {
                         const username = positional[0] || flags.username;
                         if (!username)
                             err('<username> required');
-                        const acc = sv.getAccount(platform, username);
-                        if (!acc)
-                            err(`twitter account "${username}" not found locally`, EXIT.NOT_FOUND);
+                        const acc = await ensureLocalAccount(username);
                         const sess = sv.loadSession(acc.id);
                         if (!sess) {
                             return print({
@@ -4242,9 +4381,7 @@ async function main() {
                                 err('--limit must be a positive integer', EXIT.BAD_INPUT);
                             limit = Math.floor(n);
                         }
-                        const acc = sv.getAccount(platform, username);
-                        if (!acc)
-                            err(`twitter account "${username}" not found locally`, EXIT.NOT_FOUND);
+                        const acc = await ensureLocalAccount(username);
                         const sess = sv.loadSession(acc.id);
                         if (!sess || !sess.cookies || sess.cookies.length === 0) {
                             err(`No cached session for ${username}. Run 'twitter login ${username}' first.`, EXIT.NOT_FOUND);
@@ -4537,9 +4674,7 @@ async function main() {
                             err(`Invalid username "${rawNewUsername}". X requires 4-15 chars, letters/numbers/underscores only. ` +
                                 `You have NOT been charged.`, EXIT.BAD_INPUT);
                         }
-                        const acc = sv.getAccount(platform, username);
-                        if (!acc)
-                            err(`twitter account "${username}" not found locally`, EXIT.NOT_FOUND);
+                        const acc = await ensureLocalAccount(username);
                         const sess = sv.loadSession(acc.id);
                         if (!sess || !sess.cookies || sess.cookies.length === 0) {
                             err(`No cached session. Run 'twitter login ${username}' first.`, EXIT.NOT_FOUND);
@@ -4582,9 +4717,7 @@ async function main() {
                         const username = positional[0] || flags.username;
                         if (!username)
                             err(`<username> required`);
-                        const acc = sv.getAccount(platform, username);
-                        if (!acc)
-                            err(`twitter account "${username}" not found locally`, EXIT.NOT_FOUND);
+                        const acc = await ensureLocalAccount(username);
                         const sess = sv.loadSession(acc.id);
                         if (!sess || !sess.cookies || sess.cookies.length === 0) {
                             err(`No cached session for ${username}. Run 'twitter login ${username}' first.`, EXIT.NOT_FOUND);
@@ -4889,8 +5022,338 @@ async function main() {
                     case 'status': {
                         err(`twitter status: not wired yet. Phase 3 will add it.`, EXIT.GENERAL);
                     }
+                    case 'transfer': {
+                        // Hand the X account to another wallet. End-to-end one-command:
+                        //   1. If the account is only in the local vault, auto-register it
+                        //      with the server (uploads encrypted creds; $0.01 USDC).
+                        //   2. Server rotates the password and revokes other sessions
+                        //      ($0.0001 USDC ownership proof).
+                        //   3. Atomically flips ownership in the DB.
+                        // Receiver picks up the rotated credentials via `palmyr twitter
+                        // list` (which now surfaces server-side accounts) and/or `claim`.
+                        const username = positional[0] || flags.username;
+                        const to = flags.to;
+                        if (!username)
+                            err('<username> required');
+                        if (!to)
+                            err('--to <wallet> required');
+                        const acc = sv.getAccount(platform, username);
+                        if (!acc)
+                            err(`twitter account "${username}" not found locally — can only transfer accounts you own`, EXIT.NOT_FOUND);
+                        if (!flags.confirm) {
+                            const tail = to.slice(-6);
+                            err(`This rotates @${username} on X and hands it to a wallet ending in …${tail}. ` +
+                                `You will lose access immediately and irreversibly. ` +
+                                `If the account isn't on the Palmyr server yet, it will be auto-registered (~$0.01 USDC) before the transfer.\n\n` +
+                                `Re-run with --confirm:\n` +
+                                `  palmyr twitter transfer ${username} --to ${to} --confirm`);
+                        }
+                        let resolved = await resolveServerAccount(username);
+                        // Auto-register if the account is only in the local vault. This
+                        // is the most common case for accounts that were imported BYO and
+                        // never explicitly registered. We pull creds straight from the
+                        // local vault so the user doesn't have to re-type anything.
+                        if (!resolved) {
+                            const spinReg = new Spinner();
+                            spinReg.start(`@${username} not on server yet — auto-registering before transfer…`);
+                            let regData;
+                            try {
+                                const localCreds = sv.unlockCredentials(platform, username);
+                                if (!localCreds.password) {
+                                    spinReg.stop('Register failed', false);
+                                    err(`Cannot auto-register @${username}: local vault has no password. ` +
+                                        `Re-import the account with a password first.`, EXIT.BAD_INPUT);
+                                }
+                                const country = sv.getCountry(platform, username);
+                                regData = await ao.socialTwitterRegister(username, localCreds.password, {
+                                    login: localCreds.login,
+                                    email: localCreds.email,
+                                    email_password: localCreds.email_password,
+                                    totp_seed: localCreds.totp_seed,
+                                    auth_token: localCreds.auth_token,
+                                    ct0: localCreds.ct0,
+                                    country,
+                                });
+                            }
+                            catch (e) {
+                                spinReg.stop('Register failed', false);
+                                err(`Auto-register failed: ${e.message}`, EXIT.GENERAL);
+                            }
+                            if (!regData?.success || !regData?.id) {
+                                spinReg.stop('Register failed', false);
+                                err(`Auto-register failed: ${regData?.error || 'unknown'}` +
+                                    (regData?.login_error_code ? ` [${regData.login_error_code}]` : '') +
+                                    `\nFix the credentials in the local vault, then re-run the transfer.`, EXIT.GENERAL);
+                            }
+                            spinReg.stop('Registered', true);
+                            resolved = { kind: 'registered', id: regData.id };
+                        }
+                        const spin = new Spinner();
+                        spin.start(`Rotating @${username} password and transferring…`);
+                        // Kick off the transfer. Server responds 202 with a transfer_id;
+                        // the rotation runs in the background to avoid Cloudflare's HTTP
+                        // timeout. We poll /transfers/:id until it terminates.
+                        let kicked;
+                        try {
+                            kicked = resolved.kind === 'x_accounts'
+                                ? await ao.xAccountTransfer(resolved.id, to)
+                                : await ao.socialTwitterRegisteredTransfer(resolved.id, to);
+                        }
+                        catch (e) {
+                            spin.stop('Transfer failed', false);
+                            err(`Transfer failed: ${e.message}`, EXIT.GENERAL);
+                        }
+                        const transferId = kicked?.transfer_id;
+                        if (!transferId) {
+                            spin.stop('Transfer failed', false);
+                            err(`Server didn't return a transfer_id. Response: ${JSON.stringify(kicked)}`, EXIT.GENERAL);
+                        }
+                        // Poll every 5s; cap at 5 minutes so a stuck transfer doesn't
+                        // hang the CLI forever. The server's own startup sweep will mark
+                        // anything still stuck after 5 min as failed.
+                        const startedAt = Date.now();
+                        const MAX_WAIT_MS = 5 * 60 * 1000;
+                        let status = null;
+                        while (true) {
+                            if (Date.now() - startedAt > MAX_WAIT_MS) {
+                                spin.stop('Timed out waiting', false);
+                                err(`Transfer ${transferId} is still in progress after 5 min. Check status with: ` +
+                                    `curl https://palmyr.ai/transfers/${transferId} (with payment header)`, EXIT.GENERAL);
+                            }
+                            await new Promise(r => setTimeout(r, 5000));
+                            try {
+                                status = await ao.transferStatus(transferId);
+                            }
+                            catch (e) {
+                                // Transient poll failures shouldn't abort — the rotation is
+                                // still running on the server. Surface it but keep polling.
+                                spin.update(`Poll error (will retry): ${e.message}`);
+                                continue;
+                            }
+                            spin.update(`Status: ${status.status}…`);
+                            if (status.status === 'completed' || status.status === 'failed')
+                                break;
+                        }
+                        if (status.status === 'failed') {
+                            spin.stop('Transfer failed', false);
+                            err(`Transfer failed: ${status.error || 'unknown'}` +
+                                (status.error_code ? ` [${status.error_code}]` : ''), EXIT.GENERAL);
+                        }
+                        spin.stop('Transferred', true);
+                        // Local vault still holds the OLD password / cookies which are
+                        // now useless. Drop the entry so we don't confuse the user with a
+                        // ghost account they can't log into.
+                        try {
+                            sv.removeAccount(platform, username);
+                        }
+                        catch { /* best effort */ }
+                        return print({
+                            ...status,
+                            source_table: resolved.kind,
+                            local_vault_cleared: true,
+                        });
+                    }
+                    case 'share': {
+                        const username = positional[0] || flags.username;
+                        const withWallet = flags.with || flags.wallet;
+                        if (!username)
+                            err('<username> required');
+                        if (!withWallet)
+                            err('--with <wallet> required');
+                        const acc = sv.getAccount(platform, username);
+                        if (!acc)
+                            err(`twitter account "${username}" not found locally`, EXIT.NOT_FOUND);
+                        const resolved = await resolveServerAccount(username);
+                        if (!resolved) {
+                            err(`@${username} is not on the server. Register it first with: palmyr twitter register ${username}`, EXIT.NOT_FOUND);
+                        }
+                        const data = resolved.kind === 'x_accounts'
+                            ? await ao.xAccountShare(resolved.id, withWallet)
+                            : await ao.socialTwitterRegisteredShare(resolved.id, withWallet);
+                        log(`twitter share: @${username} → ${withWallet}`);
+                        return print({ ...data, source_table: resolved.kind });
+                    }
+                    case 'unshare': {
+                        const username = positional[0] || flags.username;
+                        const targetWallet = flags.from || flags.wallet;
+                        const rotate = !!flags.rotate;
+                        if (!username)
+                            err('<username> required');
+                        if (!targetWallet)
+                            err('--from <wallet> required');
+                        const acc = sv.getAccount(platform, username);
+                        if (!acc)
+                            err(`twitter account "${username}" not found locally`, EXIT.NOT_FOUND);
+                        const resolved = await resolveServerAccount(username);
+                        if (!resolved) {
+                            err(`@${username} is not on the server. Register it first with: palmyr twitter register ${username}`, EXIT.NOT_FOUND);
+                        }
+                        const spin = rotate ? new Spinner() : null;
+                        if (spin)
+                            spin.start(`Unsharing @${username} and rotating password…`);
+                        let data;
+                        try {
+                            data = resolved.kind === 'x_accounts'
+                                ? await ao.xAccountUnshare(resolved.id, targetWallet, { rotate })
+                                : await ao.socialTwitterRegisteredUnshare(resolved.id, targetWallet, { rotate });
+                        }
+                        catch (e) {
+                            if (spin)
+                                spin.stop('Unshare failed', false);
+                            err(`Unshare failed: ${e.message}`, EXIT.GENERAL);
+                        }
+                        // If the server kicked off an async rotation, poll until it
+                        // settles. Same polling pattern as transfer — Playwright takes
+                        // longer than Cloudflare's HTTP response budget.
+                        if (rotate && data?.transfer_id) {
+                            const transferId = data.transfer_id;
+                            const startedAt = Date.now();
+                            const MAX_WAIT_MS = 5 * 60 * 1000;
+                            let status = null;
+                            while (true) {
+                                if (Date.now() - startedAt > MAX_WAIT_MS) {
+                                    if (spin)
+                                        spin.stop('Rotation timed out', false);
+                                    err(`Rotation ${transferId} still in progress after 5 min. ` +
+                                        `Account is unshared but cached cookies on the revoked wallet may still work until X-side expiry. ` +
+                                        `Check status at /transfers/${transferId}.`, EXIT.GENERAL);
+                                }
+                                await new Promise(r => setTimeout(r, 5000));
+                                try {
+                                    status = await ao.transferStatus(transferId);
+                                }
+                                catch (e) {
+                                    if (spin)
+                                        spin.update(`Poll error (will retry): ${e.message}`);
+                                    continue;
+                                }
+                                if (spin)
+                                    spin.update(`Rotation: ${status.status}…`);
+                                if (status.status === 'completed' || status.status === 'failed')
+                                    break;
+                            }
+                            if (status.status === 'failed') {
+                                if (spin)
+                                    spin.stop('Rotation failed', false);
+                                warn(`Unshare succeeded but rotation failed: ${status.error || 'unknown'}` +
+                                    (status.error_code ? ` [${status.error_code}]` : '') +
+                                    `. The revoked wallet's cached cookies may still work until X-side expiry. Retry rotation if needed.`);
+                                data = { ...data, rotated: false, rotation_error: status.error, rotation_error_code: status.error_code };
+                            }
+                            else {
+                                if (spin)
+                                    spin.stop('Unshared and rotated', true);
+                                // Fetch fresh creds from the appropriate /mine endpoint and
+                                // sync the local vault. Caller is still the owner, so the
+                                // server returns the new credentials they need.
+                                try {
+                                    const mineResp = resolved.kind === 'x_accounts'
+                                        ? await ao.xAccountsMine()
+                                        : await ao.socialTwitterRegisteredMine();
+                                    const fresh = (mineResp?.accounts || []).find((a) => a.username === username);
+                                    if (fresh) {
+                                        const existing = sv.unlockCredentials(platform, username);
+                                        const isReg = resolved.kind === 'registered';
+                                        const freshPassword = isReg ? fresh.credentials?.password : fresh.password;
+                                        const freshAuth = isReg ? fresh.credentials?.auth_token : fresh.auth_token;
+                                        const freshCookies = fresh.cookies || [];
+                                        const next = {
+                                            ...existing,
+                                            password: freshPassword || existing.password,
+                                            auth_token: freshAuth || undefined,
+                                            ct0: freshCookies.find((c) => c.name === 'ct0')?.value || existing.ct0,
+                                        };
+                                        sv.replaceCredentials(platform, username, next);
+                                        if (Array.isArray(freshCookies) && freshCookies.length > 0) {
+                                            sv.saveSession(acc.id, platform, freshCookies);
+                                        }
+                                    }
+                                }
+                                catch (e) {
+                                    warn(`Local vault sync failed: ${e.message}. Run 'palmyr twitter claim' to refresh from server.`);
+                                }
+                                data = { ...data, rotated: true, credentials: { rotated: true, persisted_locally: true } };
+                            }
+                        }
+                        else {
+                            if (spin)
+                                spin.stop('Unshared (rotation skipped)', false);
+                        }
+                        log(`twitter unshare: @${username} ✗ ${targetWallet}${rotate ? ' (rotated)' : ''}`);
+                        return print({ ...data, source_table: resolved.kind });
+                    }
+                    case 'claim': {
+                        // Fetch server-side accounts the calling wallet owns or has shared
+                        // access to — from BOTH tables. x_accounts (pool-bought) and
+                        // social_registered_accounts (BYO-registered) are queried in
+                        // parallel; both contribute to the claim list. Import any not
+                        // already in the local vault so the receiver of a transfer can
+                        // pick up the account in one command.
+                        const [xRes, regRes] = await Promise.allSettled([
+                            ao.xAccountsMine(),
+                            ao.socialTwitterRegisteredMine(),
+                        ]);
+                        const xAccounts = xRes.status === 'fulfilled' ? (xRes.value?.accounts || []) : [];
+                        const regAccountsRaw = regRes.status === 'fulfilled' ? (regRes.value?.accounts || []) : [];
+                        // Normalize the registered shape (creds + cookies live in nested
+                        // fields) to the same flat shape as x_accounts so the loop below
+                        // doesn't have to branch on source.
+                        const regAccounts = regAccountsRaw.map(a => ({
+                            username: a.username,
+                            email: a.credentials?.email,
+                            password: a.credentials?.password,
+                            auth_token: a.credentials?.auth_token,
+                            cookies: a.cookies || [],
+                            access: a.access,
+                            source_table: 'registered',
+                        }));
+                        const accounts = [
+                            ...xAccounts.map(a => ({ ...a, source_table: 'x_accounts' })),
+                            ...regAccounts,
+                        ];
+                        if (accounts.length === 0) {
+                            log('No X accounts associated with your wallet on the server.');
+                            return print({ count: 0, claimed: 0, accounts: [] });
+                        }
+                        const imported = [];
+                        const skipped = [];
+                        for (const a of accounts) {
+                            const existing = sv.getAccount(platform, a.username);
+                            if (existing) {
+                                skipped.push({ username: a.username, reason: 'already in local vault' });
+                                continue;
+                            }
+                            try {
+                                const ct0 = (a.cookies || []).find((c) => c.name === 'ct0')?.value;
+                                const creds = {
+                                    login: a.email || a.username,
+                                    password: a.password,
+                                    email: a.email,
+                                    auth_token: a.auth_token || undefined,
+                                    ct0,
+                                };
+                                const summary = sv.importAccount(platform, a.username, creds, { source: 'claim' });
+                                // Save the cookies so `palmyr twitter login` can use the
+                                // cookie-fast-path instead of re-driving the login form.
+                                if (Array.isArray(a.cookies) && a.cookies.length > 0) {
+                                    sv.saveSession(summary.id, platform, a.cookies);
+                                }
+                                imported.push({ username: a.username, id: summary.id, access: a.access, source_table: a.source_table });
+                            }
+                            catch (e) {
+                                skipped.push({ username: a.username, reason: e.message });
+                            }
+                        }
+                        log(`twitter claim: imported ${imported.length}, skipped ${skipped.length} (of ${accounts.length})`);
+                        return print({
+                            count: accounts.length,
+                            claimed: imported.length,
+                            imported,
+                            skipped,
+                        });
+                    }
                     default:
-                        err(`Unknown twitter command: ${subcommand}. Try: import, list, info, rename, remove, totp, login, manual-login, session, post, reply, like, retweet, follow, unfollow, delete, list-tweets, bio, name, location, website, pfp, banner, username, buy`);
+                        err(`Unknown twitter command: ${subcommand}. Try: import, list, info, rename, remove, totp, login, manual-login, session, post, reply, like, retweet, follow, unfollow, delete, list-tweets, bio, name, location, website, pfp, banner, username, buy, transfer, share, unshare, claim`);
                 }
                 break;
             }