From c25f69f8735b44dfca54db2ae83536554b69260e Mon Sep 17 00:00:00 2001 From: Jason Woltje Date: Tue, 10 Nov 2026 14:01:21 -0600 Subject: [PATCH] fix(organization): address accounts review and rollback edge cases (#1873) --- packages/cli/README.md | 7 ++-- packages/cli/src/accounts.mjs | 12 +++--- packages/cli/tests/accounts.test.mjs | 18 +++++++- packages/organization/README.md | 13 +++--- packages/organization/src/accounts.mjs | 42 +++++++++++++++---- packages/organization/tests/accounts.test.mjs | 42 +++++++++++++++++++ 6 files changed, 110 insertions(+), 24 deletions(-) diff --git a/packages/cli/README.md b/packages/cli/README.md index 60ca800b6..114c3412b 100644 --- a/packages/cli/README.md +++ b/packages/cli/README.md @@ -1302,7 +1302,7 @@ inactive. Project settings changes are append-only and require human proof. ## Accounts `mosaic accounts` administers the instance-level accounts store locally, as the -uid owning the config directory. It requires a human shell, rejects `--tester`, +effective uid owning the config directory. It requires a human shell, rejects `--tester`, and takes no business selector or bus connection. It has no organization rights verbs. Console sign-in, sessions and membership evaluation are later Phase M slices; these commands alone do not turn accounts mode on. @@ -1323,6 +1323,7 @@ to instance role `user`; `--role operator` creates another operator. Writes requ the file revision from list. Disable, enable and signout advance `authGen`, and the last active operator cannot be disabled or removed. Removal scans ownership while holding the registry then accounts locks, refuses if the account owns an -organization (including archived organizations), and removes its memberships in +organization (including archived organizations) or any registry entry lacks its +owner metadata during creation, and removes its memberships in the same write. List reports rollback rows needing repair; its JSON omits invite -bindings and hashes. Receipts record uid and verb and omit subjects and secrets. +bindings and hashes. Receipts record effective process uid and verb and omit subjects and secrets. diff --git a/packages/cli/src/accounts.mjs b/packages/cli/src/accounts.mjs index dfb219099..7a723973b 100644 --- a/packages/cli/src/accounts.mjs +++ b/packages/cli/src/accounts.mjs @@ -39,7 +39,7 @@ function owns(user, owner, providers) { } function readOwner(root) { const owner = readJsonFile(join(root, 'owner.json'), 'organization owner', st => { - if (st.uid !== process.getuid() || (st.mode & 0o777) !== 0o600) throw new CliError('refused: unsafe organization owner', 3); + if (st.uid !== process.geteuid() || (st.mode & 0o777) !== 0o600) throw new CliError('refused: unsafe organization owner', 3); }); rejectUnknownKeys(owner, ['provider', 'iss', 'sub'], 'organization owner'); for (const key of ['provider', 'iss', 'sub']) requireString(owner[key], `owner.${key}`, { max: 2048 }); @@ -51,7 +51,7 @@ export async function accountsCommand(args, io, deps) { const parsed = parse(args); const dir = deps.configDir ?? configDir(io.env); // This is deliberately before withRegistry as well as withAccounts. - assertAccountsOwner(dir, { uid: deps.uid ?? process.getuid() }); + assertAccountsOwner(dir, { uid: deps.uid ?? process.geteuid() }); const providers = deps.system.console?.sso?.providers ?? []; const ctx = { configDir: dir, instance: deps.instance ?? basename(dir).replace(/^mosaic-/, ''), providers }; if (parsed.verb === 'list') { @@ -88,12 +88,12 @@ export async function accountsCommand(args, io, deps) { result = await withRegistry(ctx, registry => withAccounts(ctx, { ...opts, registry }, async doc => { const user = doc.users.find(u => u.id === parsed.id); if (!user) throw new CliError('refused: account not found', 2); - // Even disabled accounts keep ownership. Unknown/broken metadata refuses; - // a missing owner is tolerated only for a reservation not yet created. + // Even disabled accounts keep ownership. A real create reserves before + // writing owner.json, so any missing owner must block removal too. for (const entry of Object.values((await readRegistryLocked(registry)).orgs)) { let owner; try { owner = readOwner(entry.root); } - catch (e) { if (entry.state === 'reserved' && /not found/.test(e.message)) continue; throw e; } + catch (e) { if (/not found/.test(e.message)) throw new CliError(`refused: org-create-in-progress: ${entry.id} has no owner metadata`, 3); throw e; } if (owns(user, owner, providers)) throw new CliError(`refused: user-owns-org: ${entry.id}`, 3); } mutate(doc); @@ -102,7 +102,7 @@ export async function accountsCommand(args, io, deps) { io.stdout.write(`accounts ${parsed.verb.replace('.', ' ')}: ${added?.id ?? parsed.id ?? ''}, revision ${result.revision}\n`); } catch (e) { if (e instanceof CliError) throw e; - const error = new CliError(`refused: ${e.code ? e.code + ': ' : ''}${e.message}${e.committed ? '; accounts write committed, receipt append failed; inspect before retrying' : ''}`, 3); + const error = new CliError(`refused: ${e.code ? e.code + ': ' : ''}${e.message}${e.committed ? '; accounts write committed; durability or receipt step failed; inspect before retrying' : ''}`, 3); if (e.committed) error.committed = true; throw error; } diff --git a/packages/cli/tests/accounts.test.mjs b/packages/cli/tests/accounts.test.mjs index 7a7b437b8..377479129 100644 --- a/packages/cli/tests/accounts.test.mjs +++ b/packages/cli/tests/accounts.test.mjs @@ -5,7 +5,7 @@ import { join } from 'node:path'; import { tmpdir } from 'node:os'; import { accountsCommand } from '../src/accounts.mjs'; import { main } from '../src/cli.mjs'; -import { withRegistry } from '../../organization/src/org-registry.mjs'; +import { withRegistry, reserveOrg } from '../../organization/src/org-registry.mjs'; const providers = [{ id: 'pocket', issuer: 'https://id.example', subjects: [{ sub: 'owner' }, { sub: 'other-owner' }] }, { id: 'second', issuer: 'https://second.example', subjects: [{ sub: 'owner' }] }]; function setup(t) { const configDir = mkdtempSync(join(tmpdir(), 'a-')); chmodSync(configDir, 0o700); t.after(() => rmSync(configDir, { recursive: true, force: true })); @@ -53,3 +53,19 @@ test('mosaic main wires accounts without a bus; tester, agent and unexpected arg for (const args of [['list', '--tester'], ['list', '--subject', 'pocket:x'], ['user', 'add', 'chosen-id', '--name', 'Pat', '--subject', 'pocket:x', '--revision', '1'], ['list', '--json', '--json']]) await assert.rejects(s.run(args)); await assert.rejects(accountsCommand(['list'], { ...s.io, env: { MOSAIC_RUN_ID: 'run' } }, s.deps), /human shell/); }); + + +test('review P2-2: real reservation wins before owner.json exists, and removal refuses', async t => { + const s = setup(t); await s.run(['init']); await s.run(['user', 'add', '--name', 'Pat', '--subject', 'pocket:pat', '--revision', '1']); const id = s.read().users[1].id; + const dataRoot = join(s.configDir, 'data'); mkdirSync(dataRoot, { mode: 0o700 }); const ctx = { configDir: s.configDir, instance: 'test', dataRoot }; + const org = await reserveOrg(ctx, 'acme'); assert.equal(existsSync(join(org.root, 'owner.json')), false); + await assert.rejects(s.run(['user', 'remove', id, '--revision', '2']), /org-create-in-progress/); assert.equal(s.read().users.length, 2); assert.equal(s.read().revision, 2); +}); + + +test('host boundary and receipt use effective uid, not real uid (current design clarification)', async t => { + const s = setup(t), realUid = process.getuid, effectiveUid = process.geteuid(); + process.getuid = () => effectiveUid + 1; + try { await s.run(['init']); await s.run(['list']); const receipt = JSON.parse(readFileSync(join(s.configDir, 'accounts-receipts.jsonl'), 'utf8')); assert.equal(receipt.uid, effectiveUid); } + finally { process.getuid = realUid; } +}); diff --git a/packages/organization/README.md b/packages/organization/README.md index c62a2bf06..8c49cd991 100644 --- a/packages/organization/README.md +++ b/packages/organization/README.md @@ -599,14 +599,16 @@ M4 supplies the authorization evaluator; M2 alone grants no Console or bus acces `withAccounts(ctx, {revision, verb, actor?, registry?, init?}, mutate)` takes `accounts.lock`, reloads, checks the expected file revision, awaits `mutate` on a copy, maintains `authGen` and membership `rev`, validates and atomically replaces -0600 bytes. `ctx` contains `configDir`, `instance`, and `providers`. Init requires +0600 bytes. Init publishes with a no-clobber hard link; replacements use rename. +Both fsync the config directory before the receipt is appended. `ctx` contains `configDir`, `instance`, and `providers`. Init requires revision 0 and an absent file. Other writes require an existing valid file. Writes -refuse unknown rights/roles, including retained rollback rows; repair those rows -before writing. Role templates are never evaluated as authority by this store. +refuse unknown rights/roles on new or changed rows. Unchanged rollback rows pass +through exactly, so they cannot block account revocation or another row's repair. Role templates are never evaluated as authority by this store. For a caller already holding accounts.lock, `withAccountsLock(ctx, handle => withAccountsLocked(handle, options, mutate))` reuses that live opaque handle. Never acquire an earlier lock from the callback. +The config path must have no symlink ancestors, including the home directory. The order is lifecycle, registry, accounts. Registry-dependent writes pass the live document from `withRegistry`; `readRegistryLocked(registry, ctx?)` verifies the lock and rereads its persisted snapshot without relocking. A changed registry @@ -614,8 +616,9 @@ or an instance mismatch refuses before account publication. Callbacks cannot reuse a released handle, or run two writes at once through one handle. Each committed write appends and fsyncs one receipt under the accounts lock in -`accounts-receipts.jsonl`: OS uid, actor id, verb, old/new file revisions, changed -account ids and before/after membership rights, scope and revisions. No account +`accounts-receipts.jsonl`: effective OS uid, actor id, verb, old/new file revisions, changed +account ids with changed field names, and before/after membership rights, scope +and revisions. No account name, subject, invite binding, hash, raw token or cookie enters the receipt. The store preflights the receipt destination before replacing accounts. As with other two-file journals, a crash or IO failure between replacement and receipt diff --git a/packages/organization/src/accounts.mjs b/packages/organization/src/accounts.mjs index 8900f457c..36ba0b375 100644 --- a/packages/organization/src/accounts.mjs +++ b/packages/organization/src/accounts.mjs @@ -14,7 +14,11 @@ const HEX32 = /^[0-9a-f]{32}$/; const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/; const same = (a, b) => canonicalJson(a) === canonicalJson(b); const array = (x, at) => { if (!Array.isArray(x)) bad(`${at} must be an array`); return x; }; -const text = (x, at) => requireString(x, at, { max: 255 }); +const text = (x, at) => { + requireString(x, at, { max: 255 }); + if (/[\u0000-\u001f\u007f-\u009f\u061c\u200e\u200f\u202a-\u202e\u2066-\u2069]/.test(x)) bad(`${at} must not contain control or bidi formatting characters`); + return x; +}; const keys = (x, allowed, at) => { requireObject(x, at); rejectUnknownKeys(x, allowed, at); }; const accountId = (x, at) => { if (typeof x !== 'string' || !USER_ID.test(x)) bad(`${at} must be u- plus 12 lowercase hex characters`); }; function time(x, at) { @@ -103,6 +107,8 @@ export function checkAccounts(document, context) { if (typeof invite.tokenHash !== 'string' || !/^[0-9a-f]{64}$/.test(invite.tokenHash) || hashes.has(invite.tokenHash)) bad(`${at}.tokenHash must be a unique sha256 hex hash`); hashes.add(invite.tokenHash); accountId(invite.by, `${at}.by`); time(invite.created, `${at}.created`); time(invite.expires, `${at}.expires`); if (Date.parse(invite.expires) <= Date.parse(invite.created)) bad(`${at}.expires must follow created`); + const ttl = Date.parse(invite.expires) - Date.parse(invite.created); + if (ttl < 3600000 || ttl > 168 * 3600000) bad(`${at} validity must be between 1 and 168 hours`); if (!['open', 'used', 'revoked', 'declined', 'expired'].includes(invite.state)) bad(`${at}.state is invalid`); requireObject(invite.bind, `${at}.bind`); if (Object.hasOwn(invite.bind, 'email')) { keys(invite.bind, ['email'], `${at}.bind`); text(invite.bind.email, `${at}.bind.email`); if (!/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(invite.bind.email)) bad(`${at}.bind.email must be one address`); } @@ -124,7 +130,7 @@ export function accountsRepairs(doc) { // Check the host boundary before any read or lock. Every ancestor must be a real // directory; configDir itself belongs to this uid and is not publicly writable. -export function assertAccountsOwner(configDir, { uid = process.getuid() } = {}) { +export function assertAccountsOwner(configDir, { uid = process.geteuid() } = {}) { if (typeof configDir !== 'string' || resolve(configDir) !== configDir) fail('accounts-unsafe', 'config directory must be an absolute normalized path'); let current = parse(configDir).root; for (const part of configDir.slice(current.length).split('/').filter(Boolean)) { @@ -135,7 +141,7 @@ export function assertAccountsOwner(configDir, { uid = process.getuid() } = {}) if (st.uid !== uid) fail('accounts-unsafe', `config directory must belong to uid ${uid}: ${configDir}`); if (st.mode & 0o022) fail('accounts-unsafe', 'config directory must not be writable by group or other'); } -export function loadAccounts(file, context, { uid = process.getuid() } = {}) { +export function loadAccounts(file, context, { uid = process.geteuid() } = {}) { assertAccountsOwner(dirname(file), { uid }); const doc = readJsonFile(file, 'accounts file', st => { if (st.uid !== uid) fail('accounts-unsafe', `accounts file must belong to uid ${uid}: ${file}`); @@ -175,13 +181,17 @@ function generations(next, before, verb) { if (u.created !== old.created) bad('account created time is immutable'); } for (const m of next.memberships) { - // Unknown names always refuse a write, including unchanged rollback rows. + const old = before?.memberships.find(x => x.org === m.org && x.incarnation === m.incarnation && x.user === m.user); + // A rollback row grants nothing, but must not block unrelated account + // revocation or the repair of another row. Preserve unchanged rows exactly. + if (old && same(m, old)) continue; if (!Object.hasOwn(ROLE_RIGHTS, m.role) || m.role === 'owner') fail('unknown-role', 'unknown or ungrantable membership role'); m.rights = [...normalizeRights(m.rights)]; - const old = before?.memberships.find(x => x.org === m.org && x.incarnation === m.incarnation && x.user === m.user); m.rev = old ? old.rev + (!same(old.rights, m.rights) || !same(old.scope, m.scope) ? 1 : 0) : 1; } for (const i of next.invites) { + const old = before?.invites.find(x => x.id === i.id); + if (old && same(i, old)) continue; if (!Object.hasOwn(ROLE_RIGHTS, i.role) || i.role === 'owner') fail('unknown-role', 'unknown or ungrantable invite role'); i.rights = [...normalizeRights(i.rights)]; } @@ -192,11 +202,20 @@ function receipt(before, after, { verb, actor }, at) { if (!VERBS.has(verb)) bad('unsupported receipt verb'); if (actor !== undefined && actor !== 'human') accountId(actor, 'receipt actor'); const membership = m => ({ org: m.org, incarnation: m.incarnation, user: m.user, role: Object.hasOwn(ROLE_RIGHTS, m.role) ? m.role : 'unknown', rights: m.rights, scope: m.scope, rev: m.rev }); - return { at, uid: process.getuid(), actor: actor ?? 'human', verb, revisionBefore: before?.revision ?? 0, revisionAfter: after.revision, + return { at, uid: process.geteuid(), actor: actor ?? 'human', verb, revisionBefore: before?.revision ?? 0, revisionAfter: after.revision, users: after.users.filter(u => !before || !same(u, before.users.find(x => x.id === u.id))).map(u => u.id), + userChanges: after.users.flatMap(u => { + const old = before?.users.find(x => x.id === u.id); + const changed = ['subjects', 'name', 'instanceRole', 'state', 'authGen', 'created'].filter(key => !old || !same(u[key], old[key])); + return changed.length ? [{ id: u.id, changed }] : []; + }), removedUsers: (before?.users ?? []).filter(u => !after.users.some(x => x.id === u.id)).map(u => u.id), memberships: { before: (before?.memberships ?? []).map(membership), after: after.memberships.map(membership) } }; } +async function syncDirectory(dir) { + const fd = await fs.open(dir, constants.O_RDONLY | constants.O_DIRECTORY | constants.O_NOFOLLOW); + try { await fd.sync(); } finally { await fd.close(); } +} // Re-read under the lock, compare expected revision, validate and atomically // replace 0600 bytes, then append and fsync exactly one receipt while still held. @@ -224,7 +243,7 @@ export async function withAccountsLocked(handle, options, fn) { // Refuse unsafe receipt destinations before publishing the account change. receiptFd = await fs.open(join(ctx.configDir, 'accounts-receipts.jsonl'), constants.O_WRONLY | constants.O_APPEND | constants.O_CREAT | constants.O_NOFOLLOW | constants.O_NONBLOCK, 0o600); const st = await receiptFd.stat(); - if (!st.isFile() || st.uid !== process.getuid() || (st.mode & 0o022) || st.nlink !== 1) fail('accounts-unsafe', 'unsafe accounts receipt file'); + if (!st.isFile() || st.uid !== process.geteuid() || (st.mode & 0o022) || st.nlink !== 1) fail('accounts-unsafe', 'unsafe accounts receipt file'); temp = join(ctx.configDir, `.accounts-${randomBytes(12).toString('hex')}`); const fd = await fs.open(temp, 'wx', 0o600); try { await fd.writeFile(JSON.stringify(checked, null, 2) + '\n'); await fd.sync(); } finally { await fd.close(); } @@ -233,8 +252,13 @@ export async function withAccountsLocked(handle, options, fn) { // Defend against a non-cooperating writer even though cooperative writers // already serialize through accounts.lock. if (before) { if (!same(loadAccounts(file, ctx), before)) fail('revision-conflict', 'accounts changed before replace'); } - else { try { await fs.lstat(file); fail('accounts-exists'); } catch (e) { if (e.code !== 'ENOENT') throw e; } } - await fs.rename(temp, file); committed = true; + // Init must never replace a target, including one created by a writer that + // ignores accounts.lock. link publishes the complete inode or fails EEXIST. + if (before) await fs.rename(temp, file); + else await fs.link(temp, file); + committed = true; + if (!before) await fs.unlink(temp); + await (options.syncDirectory ?? syncDirectory)(ctx.configDir); await receiptFd.writeFile(JSON.stringify(line) + '\n'); await receiptFd.sync(); return checked; } catch (e) { if (committed) e.committed = true; throw e; } diff --git a/packages/organization/tests/accounts.test.mjs b/packages/organization/tests/accounts.test.mjs index 6a201be87..2f1c97825 100644 --- a/packages/organization/tests/accounts.test.mjs +++ b/packages/organization/tests/accounts.test.mjs @@ -4,6 +4,9 @@ import { mkdtempSync, mkdirSync, writeFileSync, readFileSync, chmodSync, symlink import { join } from 'node:path'; import { tmpdir } from 'node:os'; import { checkAccounts, loadAccounts, accountsRepairs, withAccounts, withAccountsLock, withAccountsLocked } from '../src/accounts.mjs'; +import { templateRender } from '../src/org-service.mjs'; +import { loadBusiness } from '../src/organization-config.mjs'; +import { REPO_ROLES } from './helpers.mjs'; import { withRegistry, readRegistryLocked } from '../src/org-registry.mjs'; export const OP = 'u-000000000001', USER = 'u-000000000002'; @@ -136,3 +139,42 @@ test('a failed rename preserves published bytes and appends no receipt', async t await assert.rejects(write(s, 1, d => d.users[1].authGen++, { beforeReplace: () => { const temp = readdirSync(s.configDir).find(f => f.startsWith('.accounts-')); unlinkSync(join(s.configDir, temp)); } }), { code: 'ENOENT' }); assert.equal(readFileSync(s.file, 'utf8'), before); assert.equal(readFileSync(join(s.configDir, 'accounts-receipts.jsonl'), 'utf8'), ''); assert.ok(!existsSync(join(s.configDir, 'accounts.lock'))); }); + + +test('review P2-1: rollback rows survive unrelated disable/signout but cannot be added or edited', async t => { + const d = document(), m = member(), invite = invitation(); m.role = 'future'; m.rights.push('zz.future'); invite.rights.push('zz.future'); d.memberships.push(m); d.invites.push(invite); const s = setup(t, d); + const disabled = await write(s, 1, next => next.users[1].state = 'disabled', { verb: 'user.disable' }); + assert.deepEqual(disabled.memberships, d.memberships); assert.deepEqual(disabled.invites, d.invites); + const signedOut = await write(s, 2, next => next.users[0].authGen++); assert.deepEqual(signedOut.memberships, d.memberships); assert.equal(signedOut.users[0].authGen, 2); + await assert.rejects(write(s, 3, next => next.memberships[0].scope.instances = ['coder']), /unknown/); + await assert.rejects(write(s, 3, next => next.invites[0].state = 'revoked'), /unknown/); + const repaired = await write(s, 3, next => { next.memberships[0].role = 'member'; next.memberships[0].rights = ['org.view']; }); assert.equal(repaired.memberships[0].rev, 2); assert.deepEqual(repaired.invites, d.invites); +}); +test('review P3-1: control and bidi characters refuse in names, subjects and provenance', () => { + for (const control of ['\x1b', '\x07', '\r', '\n', '\x7f', '\u0085', '\u202e', '\u2066']) for (const field of ['name', 'sub', 'via']) { + const d = document(); d.memberships.push(member()); if (field === 'via') d.memberships[0].via += control; else if (field === 'sub') d.users[1].subjects[0].sub += control; else d.users[1].name += control; + assert.throws(() => checkAccounts(d, context)); + } +}); +test('review P3-2: invite validity is between one and 168 hours inclusive', () => { + for (const hours of [0.5, 169, 87600]) { const d = document(), i = invitation(); i.expires = new Date(Date.parse(i.created) + hours * 3600000).toISOString(); d.invites.push(i); assert.throws(() => checkAccounts(d, context)); } + for (const hours of [1, 168]) { const d = document(), i = invitation(); i.expires = new Date(Date.parse(i.created) + hours * 3600000).toISOString(); d.invites.push(i); assert.equal(checkAccounts(d, context).invites.length, 1); } +}); +test('review P3-3: receipts record actual changed field names even for a misleading verb', async t => { + const s = setup(t); await write(s, 1, d => d.users[1].instanceRole = 'operator'); + const r = JSON.parse(readFileSync(join(s.configDir, 'accounts-receipts.jsonl'), 'utf8')); assert.deepEqual(r.userChanges, [{ id: USER, changed: ['instanceRole', 'authGen'] }]); +}); +test('review P3-4: directory durability failure reports committed state and appends no success receipt', async t => { + const s = setup(t); let error; + try { await write(s, 1, d => d.users[1].authGen++, { syncDirectory: async () => { throw new Error('injected directory sync failure'); } }); } catch (e) { error = e; } + assert.match(error?.message ?? '', /injected directory sync failure/); assert.equal(error.committed, true); assert.equal(loadAccounts(s.file, s).revision, 2); assert.equal(readFileSync(join(s.configDir, 'accounts-receipts.jsonl'), 'utf8'), ''); +}); +test('review P3-5: init cannot clobber a file created after its last absence check', async t => { + const s = setup(t); unlinkSync(s.file); const intruder = 'concurrent file'; + await assert.rejects(withAccounts(s, { revision: 0, verb: 'init', init: true, beforeReplace: () => writeFileSync(s.file, intruder, { mode: 0o600 }) }, d => d.users.push(user())), { code: 'EEXIST' }); + assert.equal(readFileSync(s.file, 'utf8'), intruder); assert.equal(readFileSync(join(s.configDir, 'accounts-receipts.jsonl'), 'utf8'), ''); +}); +test('review P3-6: a real business file and accounts file load with the same human id', async t => { + const s = setup(t), doc = await templateRender('acme'); doc.human = OP; mkdirSync(join(s.configDir, 'businesses')); writeFileSync(join(s.configDir, 'businesses', 'acme.json'), JSON.stringify(doc), { mode: 0o600 }); + assert.equal(loadBusiness('acme', { dir: s.configDir, rolesDir: REPO_ROLES }).human, OP); assert.equal(loadAccounts(s.file, s).users[0].id, OP); +});