@runeditrun/rer 0.2.75 → 0.2.77

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (72) hide show
  1. package/README.md +7 -2
  2. package/cli/README.md +55 -0
  3. package/cli/contract.mjs +1 -1
  4. package/cli/deploy-command.mjs +4 -2
  5. package/cli/deploy-inputs.mjs +15 -3
  6. package/cli/deploy-installation-key.mjs +71 -0
  7. package/cli/deploy-secrets.mjs +2 -0
  8. package/cli/deploy.mjs +13 -2
  9. package/cli/deployment-record.mjs +2 -0
  10. package/cli/listing.mjs +20 -0
  11. package/cli/main.mjs +2 -1
  12. package/cli/parse.mjs +5 -3
  13. package/cli/portability-migrations.mjs +46 -0
  14. package/cli/portability-worker.mjs +7 -20
  15. package/cli/portability.mjs +5 -4
  16. package/cli/runtime-front-door.mjs +1 -1
  17. package/cli/server-registry.mjs +43 -18
  18. package/cli/server-resources.mjs +38 -9
  19. package/global/CHANGELOG.md +14 -0
  20. package/global/README.md +7 -2
  21. package/global/launch/state.mjs +5 -4
  22. package/global/launch/stop.mjs +30 -8
  23. package/global/main.mjs +2 -1
  24. package/modules/dependencies/README.md +71 -1
  25. package/modules/dependencies/auth.mjs +4 -4
  26. package/modules/dependencies/crypto.mjs +6 -1
  27. package/modules/dependencies/custody.mjs +16 -0
  28. package/modules/dependencies/index.d.mts +1 -1
  29. package/modules/dependencies/index.mjs +6 -5
  30. package/modules/dependencies/schema/keys-sealed.sql +4 -0
  31. package/modules/dependencies/sealing.mjs +55 -0
  32. package/modules/dependencies/store.mjs +62 -9
  33. package/modules/deploy-kit/README.md +1 -0
  34. package/modules/deploy-kit/owner-cli.mjs +4 -2
  35. package/modules/deploy-kit/owner-rekey.mjs +69 -0
  36. package/modules/job-queue/command.mjs +8 -3
  37. package/modules/operator-auth/docs/native-accounts.md +4 -1
  38. package/modules/operator-auth/identity/oidc/aes-gcm.mjs +21 -0
  39. package/modules/operator-auth/identity/oidc/crypto.mjs +5 -12
  40. package/modules/operator-auth/index.d.mts +1 -1
  41. package/modules/portability/README.md +40 -11
  42. package/modules/portability/backfills.mjs +29 -16
  43. package/modules/portability/bridge.mjs +24 -29
  44. package/modules/portability/import.mjs +1 -2
  45. package/modules/portability/index.d.mts +1 -1
  46. package/modules/portability/ledgers.mjs +22 -0
  47. package/modules/portability/migration-history.mjs +2 -2
  48. package/modules/release/README.md +135 -3
  49. package/modules/release/catalogue.mjs +6 -2
  50. package/modules/release/listing.mjs +64 -0
  51. package/modules/release/look.mjs +26 -0
  52. package/modules/release/previous-listing.mjs +44 -0
  53. package/modules/release/produce.mjs +3 -0
  54. package/modules/release/screenshots.mjs +51 -0
  55. package/modules/release/signature.mjs +3 -2
  56. package/modules/release/source.mjs +19 -6
  57. package/modules/release/statement.mjs +8 -4
  58. package/onboarding/local/environment.mjs +2 -2
  59. package/onboarding/process-cleanup.mjs +5 -5
  60. package/onboarding/process-scope.mjs +1 -1
  61. package/onboarding/process-table.mjs +6 -4
  62. package/onboarding/process-tree.mjs +4 -4
  63. package/onboarding/schema/json-schema.mjs +4 -1
  64. package/package.json +1 -1
  65. package/scripts/publish-check/README.md +14 -0
  66. package/scripts/publish-check/assignment.py +48 -0
  67. package/scripts/publish-check/credential_assignments.mjs +75 -0
  68. package/scripts/publish-check/credential_assignments.py +70 -0
  69. package/scripts/publish-check/credential_literals.mjs +66 -0
  70. package/scripts/publish-check/credential_syntax.mjs +29 -0
  71. package/scripts/publish-check/env_values.py +14 -1
  72. package/scripts/publish-check/history_scan.py +9 -2
@@ -32,12 +32,13 @@ async function request(record, action) {
32
32
  return new Promise((resolveRequest,reject)=>{
33
33
  const socket=createConnection(record.control);let text='';
34
34
  socket.setTimeout(35000,()=>socket.destroy(Error('Managed server did not complete cleanup.')));
35
- socket.on('connect',()=>socket.end(JSON.stringify({token:record.token,action})));
35
+ socket.on('connect',()=>socket.end(JSON.stringify({token:record.token,checkout:record.checkout,generation:record.generation,action})));
36
36
  socket.on('data',chunk=>{text+=chunk;if(text.length>16384)socket.destroy(Error('Invalid managed server reply.'));});
37
- socket.on('end',()=>{try{const value=JSON.parse(text);if(value.token!==record.token)throw Error('Unverified server');resolveRequest(value);}catch(error){reject(error);}});
37
+ socket.on('end',()=>{try{const value=JSON.parse(text);if(value.token!==record.token||value.checkout!==record.checkout||value.generation!==record.generation)throw Error('Unverified checkout server');resolveRequest(value);}catch(error){reject(error);}});
38
38
  socket.on('error',reject);
39
39
  });
40
40
  }
41
+ export const serverStatus = record => request(record,'status');
41
42
 
42
43
  // A new server starts only while this much memory is available. An idle dev
43
44
  // server holds 0.5-1.3 GiB (preview 0.4-0.8 GiB), so 1.5 GiB leaves room for the
@@ -107,42 +108,61 @@ export async function serverRegistry(root,{env=process.env,memory=availableMemor
107
108
  }
108
109
  const change=async action=>{await (secured??=secure());return transaction(directory,lifetime.info,action,{validateState});};
109
110
  let owned, control, closing;
110
- async function inspect(state) {
111
+ async function inspect(state,{recover=false}={}) {
111
112
  const kept=[];
112
113
  for(const record of state.running){
113
- let live;try{live=await alive(record.owner);}catch{throw refuse(`Unverifiable server identity: ${description(record)}. Preserve it for inspection.`);}
114
+ let current;
115
+ try{current=await processInfo(record.owner?.pid);}catch{current=undefined;}
116
+ let live=false;
117
+ // Other roots remain counted under their existing lifetime protocol; this
118
+ // client never acquires stop/recovery authority over those live records.
119
+ if(record.checkout!==checkout||record.owner?.checkout===record.checkout&&current&&current.title===record.owner.command){
120
+ try{live=await alive(record.owner);}catch{}
121
+ }
114
122
  if(live) kept.push(record);
115
123
  else {
116
- const current=await processInfo(record.owner.pid);
117
- if(current&&!current.zombie&&current.start===record.owner.start)throw refuse(`Server lifetime cannot be verified: ${description(record)}. Preserve its process.`);
118
- // A runtime capability grants recovery only to the captured process scope.
119
- if(record.runtime) {
124
+ // Fleet inspection is passive. In particular --stop never recovers an
125
+ // abandoned runtime, nor grants custody to a replacement at a recycled PID.
126
+ // Only a new start in the owning checkout may recover its dead owner's scope.
127
+ if(recover&&record.checkout===checkout&&record.owner?.checkout===checkout&&current===null&&record.runtime) {
120
128
  const { shared }=await import('./shared.mjs');
121
129
  const { recoverCommand }=await shared('command-recovery.mjs');
122
130
  await recoverCommand(record.runtime);
123
131
  }
132
+ process.stderr.write(`Dropped stale or unverified ${record.mode} server entry for ${record.checkout}; no stop signal was sent to its recorded PID.\n`);
124
133
  }
125
134
  }
126
135
  state.running=kept;
127
136
  }
128
- async function existing(mode,options,{stop=false}={}) {
137
+ async function existing(mode,options) {
129
138
  return change(async state=>{
130
- await inspect(state);const record=state.running.find(item=>item.checkout===checkout);
139
+ await inspect(state,{recover:true});const record=state.running.find(item=>item.checkout===checkout);
131
140
  if(!record)return null;
132
141
  if(record.mode!==mode)throw refuse(`This checkout already owns ${description(record)}.`);
133
- if(!stop && (options.supplied.has('--host')&&record.host!==undefined&&options.host!==record.host || options.supplied.has('--port')&&record.port!==undefined&&options.port!==record.port || options.supplied.has('--idle-timeout')&&options.idleTimeout!==record.idleTimeout))throw refuse(`Options conflict with ${description(record)}.`);
142
+ if(options.supplied.has('--host')&&record.host!==undefined&&options.host!==record.host || options.supplied.has('--port')&&record.port!==undefined&&options.port!==record.port || options.supplied.has('--idle-timeout')&&options.idleTimeout!==record.idleTimeout)throw refuse(`Options conflict with ${description(record)}.`);
134
143
  return record;
135
144
  });
136
145
  }
137
- async function stop(mode,options) {
146
+ async function stop(mode) {
138
147
  try{await lstat(join(directory,'state.json'));}catch(error){if(error.code==='ENOENT')return;throw error;}
139
- const record=await existing(mode,options,{stop:true});if(!record)return;
140
- await request(record,'stop');
141
- await change(state=>{state.running=state.running.filter(item=>item.generation!==record.generation);});
148
+ // Capture the generations once: a later start is a separate run, even in
149
+ // this root, and must not be caught by a continuing stop lookup.
150
+ const records=await change(async state=>{await inspect(state);return state.running.filter(item=>item.checkout===checkout);});
151
+ for(const record of records){
152
+ if(record.mode!==mode)throw refuse(`This checkout already owns ${description(record)}.`);
153
+ // A status reply proves this root and generation before a stop request.
154
+ try{await serverStatus(record);}
155
+ catch{
156
+ await change(state=>{state.running=state.running.filter(item=>item.generation!==record.generation);});
157
+ process.stderr.write(`Dropped foreign or unverified ${mode} server entry for ${checkout}; no stop request was sent.\n`);continue;
158
+ }
159
+ await request(record,'stop');
160
+ await change(state=>{state.running=state.running.filter(item=>item.generation!==record.generation);});
161
+ }
142
162
  }
143
163
  async function reserve(mode,options) {
144
164
  return change(async state=>{
145
- await inspect(state);
165
+ await inspect(state,{recover:true});
146
166
  const same=state.running.find(item=>item.checkout===checkout);
147
167
  if(same)return {existing:same};
148
168
  // Journeys are listed but uncounted: they neither use nor lower the cap.
@@ -152,7 +172,8 @@ export async function serverRegistry(root,{env=process.env,memory=availableMemor
152
172
  // Unreadable memory is not a reason to refuse; only a reading below the floor is.
153
173
  const available=journey||floor===0?NaN:await memory();
154
174
  if(available<floor)throw refuse(memoryMessage(counted,available,floor,mode));
155
- owned={checkout,mode,journey,generation:randomUUID(),token:randomUUID(),owner:lifetime.info,limit:fileLimit?fileLimit.limit:limit,explicit:explicit||Boolean(fileLimit),startedAt:Number(process.hrtime.bigint()/1000000n),idleTimeout:options.idleTimeout};
175
+ const {title:command}=await processInfo(process.pid);
176
+ owned={checkout,mode,journey,generation:randomUUID(),token:randomUUID(),owner:{...lifetime.info,checkout,command},limit:fileLimit?fileLimit.limit:limit,explicit:explicit||Boolean(fileLimit),startedAt:Number(process.hrtime.bigint()/1000000n),idleTimeout:options.idleTimeout};
156
177
  owned.lastActivity=owned.startedAt;owned.active=0;
157
178
  const name=`rer-server-${createHash('sha256').update(owned.generation).digest('hex').slice(0,20)}.sock`;
158
179
  owned.control=join(tmpdir(),name);if(Buffer.byteLength(owned.control)>=100)owned.control=join('/tmp',name);
@@ -165,7 +186,11 @@ export async function serverRegistry(root,{env=process.env,memory=availableMemor
165
186
  let text='';socket.setTimeout(35000,()=>socket.destroy());
166
187
  socket.on('data',data=>{text+=data;if(text.length>1024)socket.destroy();});
167
188
  socket.on('end',async()=>{
168
- try{const request=JSON.parse(text);if(request.token!==owned.token)throw Error('Invalid capability');socket.end(JSON.stringify({...await handler(request.action),token:owned.token}));}
189
+ try{
190
+ const request=JSON.parse(text);
191
+ if(request.token!==owned.token||request.action==='stop'&&(request.checkout!==checkout||request.generation!==owned.generation))throw Error('Invalid checkout capability');
192
+ socket.end(JSON.stringify({...await handler(request.action),token:owned.token,checkout,generation:owned.generation}));
193
+ }
169
194
  catch{socket.destroy();}
170
195
  });
171
196
  });
@@ -1,12 +1,14 @@
1
1
  import {loadavg,tmpdir} from 'node:os';
2
- import {statfs} from 'node:fs/promises';
2
+ import {statfs,lstat,readdir} from 'node:fs/promises';
3
+ import {dirname,join,resolve} from 'node:path';
3
4
  import {refuse} from './errors.mjs';
5
+ import {serversDirectory} from './server-registry.mjs';
4
6
  // Persistent serving is not a bounded queue job. Check its launch separately,
5
7
  // after finite preparation, while its canonical server reservation is held.
6
8
  // The 1-minute-load guard is a fleet's rule, set in the fleet's environment:
7
9
  // without RER_SERVERS_LOAD_THRESHOLD a person's start is never refused for load.
8
- // The free-disk floor is 15 GiB; a CI or managed build runner on a smaller disk
9
- // sets RER_SERVERS_DISK_FLOOR_GIB, in GiB with decimals allowed and 0 for no floor.
10
+ // Estimate another dependency/runtime-state footprint plus room for growth.
11
+ // RER_SERVERS_DISK_FLOOR_GIB explicitly replaces the estimate (0 disables it).
10
12
  export function servingLoadThreshold(env=process.env){
11
13
  if(env.RER_SERVERS_LOAD_THRESHOLD===undefined)return Infinity;
12
14
  const threshold=Number(env.RER_SERVERS_LOAD_THRESHOLD);
@@ -14,20 +16,47 @@ export function servingLoadThreshold(env=process.env){
14
16
  return threshold;
15
17
  }
16
18
  const gibibyte=1024n**3n;
17
- export function serversDiskFloor(env=process.env){
19
+ export function serversDiskFloor(env=process.env,seedBytes=0n){
18
20
  const value=env.RER_SERVERS_DISK_FLOOR_GIB;
19
- if(value===undefined)return {gib:15,bytes:15n*gibibyte};
21
+ if(value===undefined){
22
+ const estimate=2n*seedBytes+gibibyte/4n,bytes=estimate>gibibyte?estimate:gibibyte;
23
+ return {gib:Number(bytes)/Number(gibibyte),bytes};
24
+ }
20
25
  const gib=Number(value);
21
26
  if(!/^(\d+\.?\d*|\.\d+)$/.test(value)||!Number.isFinite(gib))throw refuse('Invalid server disk floor. RER_SERVERS_DISK_FLOOR_GIB must be a number of GiB such as 4 or 2.5, 0 for no floor.');
22
27
  return {gib,bytes:BigInt(Math.round(gib*Number(gibibyte)))};
23
28
  }
29
+ // Count logical file bytes conservatively, including pnpm's local .pnpm tree.
30
+ // Do not follow symlinks: linked packages are already in that tree, and links
31
+ // can point outside the seed or form cycles. Missing state has not been created.
32
+ async function seedDiskBytes(root){
33
+ async function bytes(path){
34
+ let info;try{info=await lstat(path,{bigint:true});}catch(error){if(error.code==='ENOENT')return 0n;throw error;}
35
+ if(info.isSymbolicLink())return 0n;
36
+ if(!info.isDirectory())return info.size;
37
+ let total=0n;
38
+ for(const name of await readdir(path))total+=await bytes(join(path,name));
39
+ return total;
40
+ }
41
+ return await bytes(join(root,'node_modules'))+await bytes(join(root,'.wrangler'));
42
+ }
43
+ // The registry or TMPDIR may not exist yet. Its nearest existing ancestor is
44
+ // on the filesystem that will receive it; retain the requested path in errors.
45
+ async function diskAt(path,disk){
46
+ try{return await disk(path,{bigint:true});}
47
+ catch(error){if(error.code!=='ENOENT'||dirname(path)===path)throw error;return diskAt(dirname(path),disk);}
48
+ }
24
49
  export async function serverResources(root,{load=()=>loadavg()[0],disk=statfs,env=process.env}={}){
25
- const threshold=servingLoadThreshold(env),floor=serversDiskFloor(env);
50
+ const threshold=servingLoadThreshold(env);
51
+ // Validate explicit values before doing any measurements.
52
+ let floor=serversDiskFloor(env);
26
53
  const measured=threshold===Infinity?0:await load();
27
54
  if(!Number.isFinite(measured)||measured>threshold)throw refuse(`Not started: this computer is busy. Its 1-minute load is ${Number.isFinite(measured)?measured.toFixed(1):'unknown'} and a server starts only at ${threshold} or below.\nTry again in a few minutes, or start it anyway with a higher threshold, for example RER_SERVERS_LOAD_THRESHOLD=${Math.ceil(Math.max(threshold,Number.isFinite(measured)?measured:0)*2)} rer dev.`);
28
- for(const path of new Set([root,tmpdir()])){
29
- const state=await disk(path,{bigint:true});
55
+ if(env.RER_SERVERS_DISK_FLOOR_GIB===undefined)floor=serversDiskFloor(env,await seedDiskBytes(root));
56
+ const temporary=resolve(env.TMPDIR||env.TMP||env.TEMP||tmpdir());
57
+ for(const path of new Set([resolve(root),temporary,serversDirectory(env)])){
58
+ const state=await diskAt(path,disk);
30
59
  const free=state.bavail*state.bsize;
31
- if(free<floor.bytes)throw refuse(`Server startup requires ${floor.gib} GiB free on checkout and temporary volumes, and ${path} has ${(Number(free*10n/gibibyte)/10).toFixed(1)} GiB free. Recover owned space before retrying.\nA CI runner on a small disk can lower the floor with RER_SERVERS_DISK_FLOOR_GIB (for example 4).`);
60
+ if(free<floor.bytes)throw refuse(`Server startup requires ${floor.bytes} bytes free (${floor.gib.toFixed(2)} GiB) at ${path}; it has ${free} bytes free (${(Number(free)/Number(gibibyte)).toFixed(2)} GiB). Recover owned space before retrying.\nRER_SERVERS_DISK_FLOOR_GIB explicitly overrides the seed-sized floor (GiB, decimals allowed, 0 for no floor).`);
32
61
  }
33
62
  }
@@ -1,5 +1,19 @@
1
1
  # Changelog
2
2
 
3
+ ## 0.2.77
4
+
5
+ - **Dependency signing keys are sealed at rest with a rotatable installation key (#367, #382).** Each interface's private signing key is stored as an AES-256-GCM envelope under a key derived from the generated `INSTALLATION_KEY` setting, which setup and hosted deploys keep beside `SESSION_SECRET` and archives never carry. Legacy plaintext keys upgrade once. `rer deploy --rotate-secret INSTALLATION_KEY` re-seals every row and retires the previous binding; `rer deploy --reopen-installation-key KID` reopens a D1 restore from before a rotation with retained private custody, reporting the D1 key history first. Missing or wrong keys fail closed with `installation_key_missing` or `installation_key_unavailable`.
6
+ - **The Run page keeps its install command whole at the shell pipe.** At phone widths the command wraps before the URL, or after its last slash, never beside `| sh`; Copy still copies the exact command.
7
+ - **The misbound-port startup check no longer races the app's own sockets.** Its test picks the wrong port the way rer picks its internal one, outside the OS ephemeral range, so the app's Miniflare sockets cannot take it before Vite binds.
8
+
9
+ ## 0.2.76
10
+
11
+ - **Patch the maintained TanStack Start security closure (#386).** The default seed and foundation carry the patched Start and server-core dependencies for GHSA-qx66-fv34-fjm8.
12
+ - **Restore across native and Platform migration ledgers (#368, #380, #379).** Match migration files by digest, preserve alias-aware ledger checks, and replay later inserts into carried tables after archived rows are restored.
13
+ - **Carry seed listing metadata through releases (#372).** Listing facts and reusable screenshots follow the release artifact.
14
+ - **Keep runtime custody through exec (#352) and measure actual dev write paths (#383).** Process custody stays within the installation root, and disk admission measures the seed's write paths with the WSL temporary-directory floor.
15
+ - **Correct publication scanning (#371, #387, #389).** Use hosted credential-assignment rules, reject comma-neighbour false assignments, and match environment values only when secret-shaped. Documentation examples use public repository references or explicit logical identifiers.
16
+
3
17
  ## 0.2.75
4
18
 
5
19
  - **Custom-origin owner claims use the recorded app origin (#374).** Native deployment inspection retains the configured public origin from the deployment receipt, so owner claim and status work for custom domains while the ownership guard still refuses a claim at a different origin. Existing workers.dev deployments keep their derived origin.
package/global/README.md CHANGED
@@ -190,8 +190,13 @@ or does not report its own (`rer describe` reports `defaults`), so a current
190
190
  checkout never records a limit you did not set.
191
191
  A start is never refused for machine load alone unless `RER_SERVERS_LOAD_THRESHOLD`
192
192
  or `RER_JOBS_LOAD_THRESHOLD` is set; memory and disk guards stay. The disk guard
193
- needs 15 GiB free; `RER_SERVERS_DISK_FLOOR_GIB=N` changes it (CI runners may set
194
- it lower, for example 4; people should not).
193
+ measures installed `node_modules` and `.wrangler` (including local D1 state). It
194
+ requires twice those bytes plus 256 MiB, with a 1 GiB minimum, on the checkout,
195
+ the selected temporary directory (`TMPDIR`, then `TMP`/`TEMP`, then the OS
196
+ default), and the actual `RER_SERVERS_DIR` or home registry directory. A refusal
197
+ names the path and exact free and required bytes.
198
+ `RER_SERVERS_DISK_FLOOR_GIB=N` explicitly replaces this estimate (GiB, decimals
199
+ allowed, 0 disables the floor).
195
200
 
196
201
  ## The front door
197
202
 
@@ -10,7 +10,7 @@
10
10
  // stop.json when rer dev --stop last ran: a launch requested before it stops
11
11
  // pin-install.json the process installing the checkout's pinned rer package
12
12
  import { createHash } from 'node:crypto';
13
- import { appendFile, link, mkdir, readFile, readdir, rm, writeFile } from 'node:fs/promises';
13
+ import { appendFile, link, mkdir, readFile, readdir, realpath, rm, writeFile } from 'node:fs/promises';
14
14
  import { basename, join } from 'node:path';
15
15
  import { processInfo } from '../../modules/job-queue/processes.mjs';
16
16
  import { serversDirectory } from '../registry.mjs';
@@ -35,9 +35,10 @@ async function live(holder) {
35
35
  }
36
36
 
37
37
  export async function liveWorker(directory) {
38
- const holder = await readJson(join(directory, 'worker.json'));
38
+ const holder = await readWorker(directory);
39
39
  return await live(holder) ? holder : undefined;
40
40
  }
41
+ export const readWorker = directory => readJson(join(directory, 'worker.json'));
41
42
 
42
43
  // A claim file is written to a private file first and hard-linked into place,
43
44
  // so it appears complete or not at all: a process finding it never reads a
@@ -101,8 +102,8 @@ export async function settledPinInstall(checkout, { env = process.env, signal, o
101
102
  export async function claimLaunch(directory, token) {
102
103
  const path = join(directory, 'worker.json');
103
104
  for (let attempt = 0; attempt < 3; attempt++) {
104
- const { start } = await processInfo(process.pid);
105
- if (await linkClaim(path, { token, pid: process.pid, start, startedAt: Date.now(), events: `events-${token}.jsonl` })) {
105
+ const { start, title: command } = await processInfo(process.pid), checkout = await realpath(process.cwd());
106
+ if (await linkClaim(path, { token, pid: process.pid, start, command, checkout, startedAt: Date.now(), events: `events-${token}.jsonl` })) {
106
107
  for (const entry of await readdir(directory)) if (/^events-.*\.jsonl$/.test(entry) && entry !== `events-${token}.jsonl`) await rm(join(directory, entry), { force: true });
107
108
  return true;
108
109
  }
@@ -5,22 +5,34 @@
5
5
  // the registered server and everything they spawned -- has exited. It says
6
6
  // what it stopped, or exits non-zero naming what is still running.
7
7
  import { setTimeout as delay } from 'node:timers/promises';
8
+ import { fileURLToPath } from 'node:url';
9
+ import { join } from 'node:path';
10
+ import { rm } from 'node:fs/promises';
8
11
  import { processInfo } from '../../modules/job-queue/processes.mjs';
9
12
  import { readProcessTable, sameBirth } from '../../onboarding/process-table.mjs';
10
13
  import { delegate } from '../delegate.mjs';
11
14
  import { liveServers } from '../registry.mjs';
15
+ import { serverStatus } from '../../cli/server-registry.mjs';
12
16
  import { LaunchFailure } from './failure.mjs';
13
- import { liveWorker, serverRecord, stopRequest } from './state.mjs';
17
+ import { readWorker, serverRecord, stopRequest } from './state.mjs';
14
18
 
15
19
  export async function stopLaunch(target, devArgs, { checkout, directory }) {
16
20
  // Written before looking for a worker: one that claims the launch after this
17
21
  // look reads it and ends itself (worker.mjs).
18
22
  await stopRequest.write(directory);
19
- const holder = await liveWorker(directory);
20
- const launch = holder ? await tree([holder]) : [];
21
- if (holder) await endWorker(holder);
23
+ const holder = await readWorker(directory);
24
+ const verified = holder && await verifiedWorker(holder, checkout);
25
+ const launch = verified ? await tree([holder]) : [];
26
+ if (verified) await endWorker(holder, checkout);
27
+ else if (holder) {
28
+ await rm(join(directory, 'worker.json'), { force: true });
29
+ process.stderr.write(`Dropped foreign or unverified launch worker entry for ${checkout}; no signal was sent.\n`);
30
+ }
22
31
  // Only now: a worker stopped while its server came up has registered it.
23
- const record = (await liveServers()).find(item => item.checkout === checkout);
32
+ let record;
33
+ for (const candidate of (await liveServers()).filter(item => item.checkout === checkout)) {
34
+ try { await serverStatus(candidate); record = candidate; break; } catch {}
35
+ }
24
36
  const started = await serverRecord.read(directory);
25
37
  const server = await tree([record?.owner, record?.runtimeProcess, started, started?.spawned]);
26
38
  await delegate(target, ['dev', ...devArgs]);
@@ -28,15 +40,25 @@ export async function stopLaunch(target, devArgs, { checkout, directory }) {
28
40
  const left = await exited([...launch, ...server], 15000);
29
41
  if (left.length) {
30
42
  const pids = left.map(item => item.pid).join(' ');
31
- process.stderr.write(`rer dev --stop: ${left.length === 1 ? 'a process' : `${left.length} processes`} of this checkout's dev server ${left.length === 1 ? 'is' : 'are'} still running 15 seconds after the stop (PID ${pids}). Stop ${left.length === 1 ? 'it' : 'them'} with kill -TERM ${pids}, then run rer dev --stop again.\n`);
43
+ process.stderr.write(`rer dev --stop: ${left.length === 1 ? 'a process' : `${left.length} processes`} recorded for this checkout's dev server ${left.length === 1 ? 'is' : 'are'} still running 15 seconds after the stop (PID ${pids}). Preserve these processes and inspect their ownership before stopping them.\n`);
32
44
  return 1;
33
45
  }
34
- if (!devArgs.includes('--json')) process.stdout.write(said({ checkout, record, started, server, holder, launch }) + '\n');
46
+ if (!devArgs.includes('--json')) process.stdout.write(said({ checkout, record, started, server, holder:verified?holder:undefined, launch }) + '\n');
35
47
  return 0;
36
48
  }
37
49
 
38
50
  // SIGTERM the preparing worker and wait for it to exit.
39
- async function endWorker(holder) {
51
+ async function verifiedWorker(holder, checkout) {
52
+ if (!Number.isSafeInteger(holder.pid) || holder.pid < 2 || typeof holder.token !== 'string') return false;
53
+ const current = await processInfo(holder.pid);
54
+ const worker = fileURLToPath(new URL('./worker.mjs', import.meta.url));
55
+ return Boolean(current && !current.zombie && current.start === holder.start
56
+ && holder.checkout === checkout && current.title === holder.command
57
+ && current.title.includes(`${worker} ${checkout} ${holder.token} `));
58
+ }
59
+
60
+ async function endWorker(holder, checkout) {
61
+ if (!await verifiedWorker(holder, checkout)) return;
40
62
  try { process.kill(holder.pid, 'SIGTERM'); } catch (error) { if (error.code === 'ESRCH') return; throw error; }
41
63
  for (let waited = 0; waited < 60000; waited += 250) {
42
64
  const current = await processInfo(holder.pid);
package/global/main.mjs CHANGED
@@ -45,7 +45,7 @@ pins (installed first by any verb when node_modules holds another), else its ven
45
45
  of a checkout that pins the rer package use it).
46
46
 
47
47
  Checkout verbs: install, setup, dev, demo, preview, build, verify, reset, deploy, signin, export,
48
- import, doctor, describe, check, release. Run rer VERB --help in a checkout for its flags.
48
+ import, doctor, describe, check, release, listing. Run rer VERB --help in a checkout for its flags.
49
49
  `;
50
50
 
51
51
  // The checkout verbs that install the pinned package before they run when
@@ -64,6 +64,7 @@ export async function main(argv) {
64
64
  // verb never inherits it.
65
65
  delete process.env[localDefaults];
66
66
  if (verb === 'update') return (await import('./update/command.mjs')).update(argv.slice(1));
67
+ if (verb === 'listing') return (await import('../cli/listing.mjs')).dispatchListing(argv.slice(1));
67
68
  if (verb === 'business') return (await import('../cli/business/command.mjs')).businessCommand(argv.slice(1));
68
69
  if (verb === 'companion') return (await import('../cli/companion/command.mjs')).companionCommand(argv.slice(1));
69
70
  const notice = await import('./update/notice.mjs');
@@ -32,7 +32,77 @@ adapter adds OIDC discovery, sessions, domain policy and owner claims.
32
32
  same-origin `paths` as absolute URLs, and a per-interface `jwks_uri`.
33
33
  `GET /.well-known/rer-link/jwks/INTERFACE` publishes an ES256 public JWK only.
34
34
  The unqualified JWKS URL selects the identity interface. The application retains
35
- its private key in the server database. Sector/install identity survives re-link,
35
+ its private key in the server database as an AES-256-GCM envelope
36
+ `{version:1,kid,iv,ciphertext}`. The 96-bit random IV and 128-bit tag authenticate the
37
+ AAD `rer-at-rest-v1|rer_dependency_keys|<interface>|1|<kid>`, binding the table,
38
+ interface, envelope version and installation key ID. HKDF-SHA-256 derives a
39
+ dedicated encryption key from
40
+ `INSTALLATION_KEY` with the `rer-at-rest-v1:dependency-key` domain. The envelope's
41
+ `kid` identifies that installation secret; it is separate from the signing JWK's ID.
42
+ `INSTALLATION_KEY` requires the generated 256-bit key's 64 lowercase hex
43
+ characters; passphrases and other formats are refused. `rer setup` generates the
44
+ secret in the private settings file; hosted deploys
45
+ keep their own generated secret in `.rer/deploy/<environment>.secrets.env`
46
+ (mode 0600), exactly like `SESSION_SECRET`. Neither secret enters archives.
47
+ Pass both installation bindings to `createDependencies` and `AuthConfig`.
48
+
49
+ Legacy plaintext is accepted only before the installation records sealed
50
+ custody; a read upgrades the requested interface, and full rekey upgrades every
51
+ row in one D1 batch. After the last legacy key is upgraded, the durable
52
+ `keys_sealed` marker prevents plaintext from being reintroduced. The non-secret
53
+ `key_ids` history distinguishes retired versions from damaged envelopes. An
54
+ optional `INSTALLATION_KEY_PREVIOUS` permits reads across rotation; old rows
55
+ are re-sealed under the current key. Missing keys, malformed envelopes, wrong
56
+ keys and changed interface AAD fail closed with `installation_key_missing` or
57
+ `installation_key_unavailable` (503), without treating ciphertext as plaintext.
58
+ Rotate hosted custody with `rer deploy --rotate-secret INSTALLATION_KEY`:
59
+ rer retains both values privately, publishes both bindings in one Worker version,
60
+ re-seals every row, checks that every row opens with only the current key, then
61
+ retires the previous Worker binding. Routine rotation uses only the current/previous
62
+ pair; older retired keys require explicit reopen. By default, every retired
63
+ private value stays in the same 0600, Git-ignored file as `SESSION_SECRET`, in
64
+ `INSTALLATION_KEY_RETIRED=<kid>:<value>[,<kid>:<value>...]`; none is routinely
65
+ bound to the Worker. An interrupted operation resumes with the same pair. Back
66
+ up this private custody securely and retain it when moving checkouts.
67
+
68
+ Retain each retired key until no D1 Time Travel recovery point or exported backup
69
+ predates the completed rotation that retired it or otherwise needs that key.
70
+ After any rotation or reopen has finished, edit
71
+ `.rer/deploy/<environment>.secrets.env` and remove only its `<kid>:<value>` entry
72
+ from `INSTALLATION_KEY_RETIRED`, keeping valid comma separators; remove the
73
+ assignment if no entries remain. Preserve the current key, all other entries
74
+ and the file's owned 0600 permissions. There is no per-key removal command;
75
+ reopening a removed ID refuses before provider writes unless its custody is restored.
76
+
77
+ Restoring D1 backups or Time Travel from before a rotation may require an older
78
+ key. `rer deploy --reopen-installation-key KID` explicitly publishes the current
79
+ key and that retained retired key as `INSTALLATION_KEY_PREVIOUS`, re-seals and
80
+ verifies every row under the current key, then removes the previous binding.
81
+ CLI-side reopen rekey uses every validated retired key in private custody, so a
82
+ mid-rotation snapshot containing rows under multiple retired keys can be reopened
83
+ with either retained ID. Only the selected pair is published to the Worker.
84
+ Reopen/rekey reports the D1 `key_ids` tail and whether each history ID is in
85
+ custody before opening rows, including when the tail check refuses the restore.
86
+ It retains retired custody and resumes the same pair after interruption. Missing
87
+ retired custody refuses with `installation_key_unavailable`; recover the private
88
+ file before reopening. A whole pre-rotation D1 restore also restores `key_ids`:
89
+ if its tail is absent from configured custody, reads refuse with
90
+ `installation_key_unavailable` before inspecting envelopes. When that custody
91
+ check succeeds, a historically known envelope key ID whose key is no longer
92
+ configured yields `installation_key_version_unknown` (for example, a row-only
93
+ restore that retains the current installation history);
94
+ wrong configuration, malformed ciphertext and unrecognised key IDs yield
95
+ `installation_key_unavailable`. Neither failure generates a replacement key.
96
+
97
+ Base before #367 cannot open sealed keys. Keep sealing-capable code or roll
98
+ forward after restoring D1. Current Base refuses sealed envelopes on its
99
+ plaintext signing path with `installation_key_sealed_rollback`; old binaries
100
+ cannot acquire that check retroactively.
101
+ Session rotation never changes this key.
102
+
103
+ This protects signing keys in a D1 dump or backup obtained without the Worker
104
+ secret. It does not protect them from a compromised Worker or someone holding
105
+ both the database and the installation secret. Sector/install identity survives re-link,
36
106
  provider moves and export/import. Keys are isolated per interface.
37
107
 
38
108
  Provider origins and metadata endpoints require HTTPS. Under `rer dev` (the
@@ -10,17 +10,17 @@ export function linkedProviders(options) {
10
10
  if(config.dependencies && (staticProviders?.ids.includes('auth') || staticProviders?.callbackPaths?.['/auth/oidc/auth/callback'])) throw new Error('dependency_provider_conflict');
11
11
  async function current() {
12
12
  if (!config.dependencies) return staticProviders;
13
- const store=dependencyStore(db),link=await store.link();
13
+ const store=dependencyStore(db,config),link=await store.link();
14
14
  if(!link || link.needs_relink) return staticProviders;
15
- const row=await store.first("SELECT private_key FROM rer_dependency_keys WHERE interface='oidc-provider@1'");
16
- if(!row?.private_key) return null;
15
+ const row=await store.readKey();
16
+ if(!row) return null;
17
17
  const unclaimed=native?()=>native.unclaimed():async()=>!await db.prepare('SELECT 1 FROM oa_operators LIMIT 1').first();
18
18
  return createOidcProviders({...options, enabled:async()=>await options.enabled() || await unclaimed(), claim:async(request,token,expectedPin)=>{
19
19
  if(!await unclaimed())return null;
20
20
  if(native)return native.claimOwner?native.claimOwner({request,token,expectedPin}):null;
21
21
  return createIdpOwnerClaimHandler({expectedPin,db,authConfig:config,clientIp:()=>options.clientIp(request),clock:options.clock,fetch:options.fetch})(new Request(config.origin+'/auth/owner-claim',{method:'POST',headers:{Host:new URL(config.origin).host,Origin:config.origin,'Content-Type':'application/json'},body:JSON.stringify({token})}));
22
22
  }, claimScope: unclaimed, config:{origin:config.origin,local:config.local,signInPath:config.branding.signInPath,transactionSecret:config.OIDC_TRANSACTION_SECRET ?? config.SESSION_SECRET+'-oidc',providers:[{
23
- id:'auth',preset:'auth',issuer:link.issuer,clientId:link.client_id,privateKey:JSON.parse(row.private_key),
23
+ id:'auth',preset:'auth',issuer:link.issuer,clientId:link.client_id,privateKey:row.key,
24
24
  }]}});
25
25
  }
26
26
  if(!config.dependencies) return staticProviders;
@@ -1,11 +1,16 @@
1
+ import { AuthError } from '../operator-auth/errors.mjs';
1
2
  const encode = bytes => btoa(String.fromCharCode(...bytes)).replaceAll('+','-').replaceAll('/','_').replace(/=+$/,'');
2
3
  const json = value => encode(new TextEncoder().encode(JSON.stringify(value)));
3
4
  export async function keyPair() {
4
5
  const pair = await crypto.subtle.generateKey({name:'ECDSA',namedCurve:'P-256'},true,['sign','verify']);
5
6
  return {...await crypto.subtle.exportKey('jwk',pair.privateKey),kid:crypto.randomUUID(),alg:'ES256',use:'sig'};
6
7
  }
7
- export function publicKey(key) { return {kty:key.kty,crv:key.crv,x:key.x,y:key.y,kid:key.kid,alg:'ES256',use:'sig',key_ops:['verify']}; }
8
+ function requirePlaintextKey(key) {
9
+ if (key && ['version','iv','ciphertext'].some(field => Object.hasOwn(key,field))) throw new AuthError('installation_key_sealed_rollback',503);
10
+ }
11
+ export function publicKey(key) { requirePlaintextKey(key);return {kty:key.kty,crv:key.crv,x:key.x,y:key.y,kid:key.kid,alg:'ES256',use:'sig',key_ops:['verify']}; }
8
12
  export async function assertion(key, claims) {
13
+ requirePlaintextKey(key);
9
14
  const encoded = `${json({alg:'ES256',typ:'JWT',kid:key.kid})}.${json(claims)}`;
10
15
  const imported = await crypto.subtle.importKey('jwk',{...key,key_ops:['sign']},{name:'ECDSA',namedCurve:'P-256'},false,['sign']);
11
16
  return `${encoded}.${encode(new Uint8Array(await crypto.subtle.sign({name:'ECDSA',hash:'SHA-256'},imported,new TextEncoder().encode(encoded))))}`;
@@ -0,0 +1,16 @@
1
+ import { installationKeyId } from './sealing.mjs';
2
+ import { AuthError } from '../operator-auth/errors.mjs';
3
+
4
+ /** Private CLI custody only; never a Worker binding or an archive field. */
5
+ export async function retiredInstallationKeys(value) {
6
+ const retired = new Map();
7
+ if (!value) return retired;
8
+ try {
9
+ for (const entry of value.split(',')) {
10
+ const [kid, secret, extra] = entry.split(':');
11
+ if (extra !== undefined || !kid || retired.has(kid) || await installationKeyId(secret) !== kid) throw new Error('invalid-retired-custody');
12
+ retired.set(kid, secret);
13
+ }
14
+ } catch { throw new AuthError('installation_key_unavailable', 503); }
15
+ return retired;
16
+ }
@@ -1,5 +1,5 @@
1
1
  import type { Database, OperatorAuth } from '../operator-auth/index.mjs';
2
- export function createDependencies<R extends string>(options: { db: Database; origin: string; name: string; provider?: string; local?: boolean; auth: OperatorAuth<R>; claimOwner?:(token:string)=>Promise<Response|null>; clock?: () => number; fetch?: typeof fetch; provides?:string[]; interfaces?: {interface:string;optional?:boolean;provider?:string;paths:string[]}[] }): {document():Promise<unknown>;handle(request:Request):Promise<Response|null>};
2
+ export function createDependencies<R extends string>(options: { db: Database; INSTALLATION_KEY?: string; INSTALLATION_KEY_PREVIOUS?: string; origin: string; name: string; provider?: string; local?: boolean; auth: OperatorAuth<R>; claimOwner?:(token:string)=>Promise<Response|null>; clock?: () => number; fetch?: typeof fetch; provides?:string[]; interfaces?: {interface:string;optional?:boolean;provider?:string;paths:string[]}[] }): {document():Promise<unknown>;handle(request:Request):Promise<Response|null>};
3
3
  export const INTERFACE:string;
4
4
  export const CALLBACK:string;
5
5
  export const PATHS:string[];
@@ -1,6 +1,7 @@
1
1
  import { nativeDependencyAuthority } from './native.mjs';
2
2
  import { approveSetup, approveOwner, approvalFence, callbacksFor } from './approval.mjs';
3
3
  import { dependencyStore } from './store.mjs';
4
+ import { openDependencyKey } from './sealing.mjs';
4
5
  import { publicKey, assertion, digest } from './crypto.mjs';
5
6
  import { isLoopbackHost } from '../operator-auth/loopback.mjs';
6
7
  import { CALLBACK, INTERFACE, PATHS, NETWORK, insist, originOf, providerMetadata } from './protocol.mjs';
@@ -8,17 +9,17 @@ import { readJson } from '../operator-auth/identity/oidc/network.mjs';
8
9
  import { readInput } from '../operator-auth/input.mjs';
9
10
  import { ownerFence, pinStatement } from './authority.mjs';
10
11
  export { INTERFACE, CALLBACK, PATHS } from './protocol.mjs';
11
- export function createDependencies({db,origin,name,provider,interfaces=[{interface:INTERFACE,provider,paths:PATHS}],provides=[],local=false,auth,claimOwner,clock=Date.now,fetch:fetcher=globalThis.fetch}) {
12
+ export function createDependencies({db,origin,name,provider,interfaces=[{interface:INTERFACE,provider,paths:PATHS}],provides=[],local=false,INSTALLATION_KEY,INSTALLATION_KEY_PREVIOUS,auth,claimOwner,clock=Date.now,fetch:fetcher=globalThis.fetch}) {
12
13
  originOf(origin,local);insist(!local || isLoopbackHost(new URL(origin).hostname));insist(Array.isArray(provides) && new Set(provides).size===provides.length && provides.every(value=>/^[a-z][a-z0-9-]*@[1-9][0-9]*$/.test(value)));
13
14
  insist(Array.isArray(interfaces) && new Set(interfaces.map(d=>d.interface)).size===interfaces.length && interfaces.every(d=>/^[a-z][a-z0-9-]*@[1-9][0-9]*$/.test(d.interface) && Array.isArray(d.paths) && new Set(d.paths).size===d.paths.length && d.paths.every(p=>typeof p==='string' && /^\/[A-Za-z0-9_~/-]+$/.test(p) && !p.startsWith('//'))));
14
- const store=dependencyStore(db);
15
+ const store=dependencyStore(db,{INSTALLATION_KEY,INSTALLATION_KEY_PREVIOUS});
15
16
  const native=auth?.native?nativeDependencyAuthority(auth.accounts.dependencies):null;
16
17
  async function owner(request,action) {
17
18
  const actor=await auth.requireStepUp(request,action), current=await auth.accounts.owner();
18
19
  insist(actor.operator.id===current?.id,'owner_required',403);return actor;
19
20
  }
20
21
  async function document() {
21
- const installation=await store.installation(interfaces[0]?.interface??INTERFACE);
22
+ const installation=await store.identity();
22
23
  const linked=await Promise.all(interfaces.map(d=>store.link(d.interface)));
23
24
  return {name,version:1,origin,sector_id:installation.sector_id,dependencies:interfaces.map((d,i)=>({provider:linked[i]?.issuer??d.provider??null,interface:d.interface,optional:d.optional??true,cardinality:1,paths:d.paths.map(p=>origin+p),jwks_uri:origin+'/.well-known/rer-link/jwks/'+d.interface})),provides,
24
25
  claim:interfaces.some(d=>d.interface===INTERFACE) && (native?await native.unclaimed():!await db.prepare('SELECT 1 FROM oa_operators LIMIT 1').first()),callback:origin+CALLBACK,jwks_uri:origin+'/.well-known/rer-link/jwks'};
@@ -48,7 +49,7 @@ export function createDependencies({db,origin,name,provider,interfaces=[{interfa
48
49
  const unchanged=old?{sql:'EXISTS(SELECT 1 FROM rer_dependency_link WHERE interface=? AND issuer=? AND client_id=? AND metadata=? AND needs_relink=? AND linked_at=?)',args:[contract,old.issuer,old.client_id,JSON.stringify(old.metadata),old.needs_relink,old.linked_at]}:{sql:'NOT EXISTS(SELECT 1 FROM rer_dependency_link WHERE interface=?)',args:[contract]};
49
50
  const approval=await approvalFence(pending,contract,expected,callbacks,clock(),pendingPin,native);
50
51
  await db.batch([
51
- db.prepare(`UPDATE rer_dependency_codes SET created_at=CASE WHEN EXISTS(SELECT 1 FROM rer_dependency_keys WHERE interface=? AND json_extract(private_key,'$.kid')=?) AND ${unchanged.sql} AND ${approval.sql} THEN created_at ELSE -1 END WHERE digest=?`).bind(contract,installation.key.kid,...unchanged.args,...approval.args,codeDigest),
52
+ db.prepare(`UPDATE rer_dependency_codes SET created_at=CASE WHEN EXISTS(SELECT 1 FROM rer_dependency_keys WHERE interface=? AND private_key=?) AND ${unchanged.sql} AND ${approval.sql} THEN created_at ELSE -1 END WHERE digest=?`).bind(contract,installation.sealedKey,...unchanged.args,...approval.args,codeDigest),
52
53
  db.prepare(`INSERT INTO rer_dependency_link(interface,issuer,client_id,metadata,needs_relink,linked_at) VALUES(?,?,?,?,0,?) ON CONFLICT(interface) DO UPDATE SET issuer=excluded.issuer,client_id=excluded.client_id,metadata=excluded.metadata,needs_relink=0,linked_at=MAX(rer_dependency_link.linked_at+1,excluded.linked_at)`).bind(contract,expected,result.client_id,JSON.stringify(metadata),clock()),
53
54
  ...(native?await native.linkedStatements({pending,contract,old,issuer:expected,now:clock()}):[
54
55
  ...(contract===INTERFACE?[db.prepare("INSERT INTO oa_auth_audit(id,actor_id,action,value,created_at) SELECT ?,claim_id,'idpSignIn','true',? FROM oa_bootstrap WHERE EXISTS(SELECT 1 FROM oa_auth_settings WHERE singleton=1 AND first_setup=1 AND idp_sign_in=0) AND EXISTS(SELECT 1 FROM oa_setup_links WHERE interface='oidc-provider@1' AND attempt_id=? AND completed=0 AND owner_id=claim_id)").bind(crypto.randomUUID(),clock(),pending.attempt_id)]:[]),
@@ -85,7 +86,7 @@ export function createDependencies({db,origin,name,provider,interfaces=[{interfa
85
86
  db.prepare("INSERT INTO oa_auth_audit VALUES(?,?,'provider:unlink',?,?)").bind(crypto.randomUUID(),actor.operator.id,contract,clock())]:[]),
86
87
  ]);
87
88
  // Local removal is already complete. The provider may be offline.
88
- if(link && key) {try {await readJson(fetcher,link.metadata.link.deregister,NETWORK,{method:'POST',headers:{'Content-Type':'application/json'},body:JSON.stringify({client_id:link.client_id,origin,interface:contract,client_assertion_type:'urn:ietf:params:oauth:client-assertion-type:jwt-bearer',client_assertion:await assertion(JSON.parse(key.private_key),{iss:link.client_id,sub:link.client_id,aud:link.metadata.link.deregister,iat:Math.floor(clock()/1000),exp:Math.floor(clock()/1000)+60,jti:crypto.randomUUID()})})});}catch{}}
89
+ if(link && key) {try {await readJson(fetcher,link.metadata.link.deregister,NETWORK,{method:'POST',headers:{'Content-Type':'application/json'},body:JSON.stringify({client_id:link.client_id,origin,interface:contract,client_assertion_type:'urn:ietf:params:oauth:client-assertion-type:jwt-bearer',client_assertion:await assertion((await openDependencyKey({INSTALLATION_KEY,INSTALLATION_KEY_PREVIOUS},contract,key.private_key)).key,{iss:link.client_id,sub:link.client_id,aud:link.metadata.link.deregister,iat:Math.floor(clock()/1000),exp:Math.floor(clock()/1000)+60,jti:crypto.randomUUID()})})});}catch{}}
89
90
  return Response.json({unlinked:true});
90
91
  }
91
92
  return {document,async handle(request) {
@@ -0,0 +1,4 @@
1
+ ALTER TABLE rer_dependency_installation ADD COLUMN keys_sealed INTEGER NOT NULL DEFAULT 0 CHECK(keys_sealed IN (0,1));
2
+ -- Nonsecret version history lets restored rows name an unavailable retired key
3
+ -- without confusing ciphertext tampering or a wrong current secret with restore.
4
+ ALTER TABLE rer_dependency_installation ADD COLUMN key_ids TEXT NOT NULL DEFAULT '[]' CHECK(json_valid(key_ids) AND json_type(key_ids)='array');
@@ -0,0 +1,55 @@
1
+ import { utf8, encode, encryptJson, decryptJson } from '../operator-auth/identity/oidc/aes-gcm.mjs';
2
+ import { AuthError } from '../operator-auth/errors.mjs';
3
+ const DOMAIN = 'rer-at-rest-v1:dependency-key';
4
+ const fail = () => { throw new AuthError('installation_key_unavailable', 503); };
5
+ function validSecret(secret) { return typeof secret === 'string' && /^[a-f0-9]{64}$/.test(secret); }
6
+ export function requireInstallationKey(config) {
7
+ if (!validSecret(config.INSTALLATION_KEY)) throw new AuthError('installation_key_missing', 503);
8
+ }
9
+ export async function installationKeyId(secret) {
10
+ requireInstallationKey({ INSTALLATION_KEY: secret });
11
+ return encode(await crypto.subtle.digest('SHA-256', utf8.encode(`${DOMAIN}:key-id\0${secret}`)));
12
+ }
13
+ const aad = (contract, kid) => `rer-at-rest-v1|rer_dependency_keys|${contract}|1|${kid}`;
14
+ async function material(secret) {
15
+ const root = await crypto.subtle.importKey('raw', utf8.encode(secret), 'HKDF', false, ['deriveKey']);
16
+ const key = await crypto.subtle.deriveKey({ name: 'HKDF', hash: 'SHA-256', salt: utf8.encode('rer-at-rest-v1'), info: utf8.encode(DOMAIN) }, root, { name: 'AES-GCM', length: 256 }, false, ['encrypt', 'decrypt']);
17
+ const kid = await installationKeyId(secret);
18
+ return { key, kid };
19
+ }
20
+ function privateJwk(value) {
21
+ return value && value.kty === 'EC' && value.crv === 'P-256' && ['x','y','d'].every(k => typeof value[k] === 'string' && /^[A-Za-z0-9_-]{43}$/.test(value[k])) && typeof value.kid === 'string' && value.kid.length > 0;
22
+ }
23
+ export async function sealDependencyKey(config, contract, value) {
24
+ requireInstallationKey(config);
25
+ if (!privateJwk(value)) fail();
26
+ const { key, kid } = await material(config.INSTALLATION_KEY);
27
+ return JSON.stringify({ version: 1, kid, ...await encryptJson(key, aad(contract, kid), value) });
28
+ }
29
+ export async function openDependencyKey(config, contract, raw, { currentOnly = false, allowPlaintext = false, knownKeyIds, retiredKeys = [] } = {}) {
30
+ requireInstallationKey(config);
31
+ let value;try { value = JSON.parse(raw); } catch { fail(); }
32
+ // Only a complete legacy private JWK is upgradeable. An envelope, even a
33
+ // malformed/unknown one, can never take the legacy plaintext branch.
34
+ if (value && !['version','iv','ciphertext'].some(k => Object.hasOwn(value,k)) && privateJwk(value)) {
35
+ if (currentOnly || !allowPlaintext) fail();
36
+ return { key: value, reseal: true };
37
+ }
38
+ if (!value || value.version !== 1 || typeof value.kid !== 'string' || typeof value.iv !== 'string' || typeof value.ciphertext !== 'string' || Object.keys(value).sort().join(',') !== 'ciphertext,iv,kid,version') fail();
39
+ const secrets = [config.INSTALLATION_KEY, ...(!currentOnly ? [...(validSecret(config.INSTALLATION_KEY_PREVIOUS) ? [config.INSTALLATION_KEY_PREVIOUS] : []), ...retiredKeys] : [])];
40
+ let matched = false;
41
+ for (let i = 0; i < secrets.length; i++) {
42
+ try {
43
+ const { key, kid } = await material(secrets[i]);
44
+ if (kid !== value.kid) continue;
45
+ matched = true;
46
+ const jwk = await decryptJson(key, aad(contract, kid), value);
47
+ if (!privateJwk(jwk)) continue;
48
+ return { key: jwk, reseal: i > 0 };
49
+ } catch { /* Try the remaining explicitly supplied custody, then refuse. */ }
50
+ }
51
+ // Known version IDs contain no key material. They distinguish a missing
52
+ // retired version from tampering or a wrong supplied installation secret.
53
+ if (!matched && (!knownKeyIds || knownKeyIds.includes(value.kid))) throw new AuthError('installation_key_version_unknown', 503);
54
+ fail();
55
+ }