@masstensor/diagnose 0.2.0 → 0.3.0

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.
package/dist/peer.d.ts CHANGED
@@ -11,6 +11,7 @@ export type PeerOptions = {
11
11
  signal: AbortSignal;
12
12
  }) => Promise<boolean>;
13
13
  approvalTimeoutMs?: number;
14
+ sessionMs?: number;
14
15
  };
15
16
  export declare function relayUrl(value: string): string;
16
17
  export declare class Peer extends EventEmitter {
package/dist/peer.js CHANGED
@@ -128,7 +128,7 @@ export class Peer extends EventEmitter {
128
128
  this.close('User declined pairing');
129
129
  return;
130
130
  }
131
- this.ws.send(JSON.stringify({ type: 'lock' }));
131
+ this.ws.send(JSON.stringify({ type: 'lock', ...(this.options.sessionMs === undefined ? {} : { ttlMs: this.options.sessionMs || 7 * 86400000 }) }));
132
132
  this.approved = true;
133
133
  await this.send({ type: 'session.accepted', label: safeText(this.options.label ?? 'User probe'), fingerprint: this.fingerprint });
134
134
  this.activate();
@@ -0,0 +1 @@
1
+ export declare function preparePty(): Promise<void>;
@@ -0,0 +1,26 @@
1
+ import { createRequire } from 'node:module';
2
+ import { dirname, join } from 'node:path';
3
+ import { stat, chmod } from 'node:fs/promises';
4
+ import { pathToFileURL } from 'node:url';
5
+ // node-pty 1.1.0's macOS prebuilt helper is shipped without its executable bit.
6
+ // Repair only that bundled helper, during installation and as a runtime fallback.
7
+ export async function preparePty() {
8
+ if (process.platform !== 'darwin')
9
+ return;
10
+ const root = dirname(createRequire(import.meta.url).resolve('node-pty/package.json'));
11
+ for (const path of [join(root, 'prebuilds', `darwin-${process.arch}`, 'spawn-helper'), join(root, 'build', 'Release', 'spawn-helper')]) {
12
+ try {
13
+ const info = await stat(path);
14
+ if (info.isFile() && !(info.mode & 0o100))
15
+ await chmod(path, info.mode | 0o100);
16
+ }
17
+ catch (error) {
18
+ if (error.code !== 'ENOENT')
19
+ throw error;
20
+ }
21
+ }
22
+ }
23
+ if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href)
24
+ await preparePty();
25
+ if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href)
26
+ preparePty().catch(() => { console.error('Unable to prepare bundled PTY helper. Reinstall diagnose with write permission to its installation directory.'); process.exitCode = 1; });
package/dist/relay.js CHANGED
@@ -111,9 +111,12 @@ export function createRelay(options = {}) {
111
111
  if (bytes.length > 128 || state.role !== 'host')
112
112
  throw new Error();
113
113
  const msg = JSON.parse(bytes.toString());
114
- if (msg.type === 'lock') {
114
+ if (msg.type === 'lock' && !room.locked) {
115
+ const requested = msg.ttlMs;
116
+ if (requested !== undefined && (!Number.isInteger(requested) || requested < 60000 || requested > 7 * 86400000))
117
+ throw new Error();
115
118
  room.locked = true;
116
- room.expires = Date.now() + (options.sessionMs ?? 3600000);
119
+ room.expires = Date.now() + (requested ?? options.sessionMs ?? 3600000);
117
120
  }
118
121
  else if (msg.type === 'reject' && !room.locked) {
119
122
  const peer = room.peer;
@@ -0,0 +1,28 @@
1
+ import { Journal } from './journal.js';
2
+ import { Audit } from './util.js';
3
+ import type { AtomicTask, ResourceRequest } from './schema.js';
4
+ export declare const resourceOperation: (operation: string) => boolean;
5
+ export declare class SessionResources {
6
+ private audit;
7
+ readonly journal: Journal;
8
+ private resources;
9
+ private writes;
10
+ constructor(root: string, audit: Audit);
11
+ setAudit(audit: Audit): void;
12
+ private create;
13
+ open(task: AtomicTask, owner: string, signal?: AbortSignal): Promise<unknown>;
14
+ control(owner: string, request: ResourceRequest): Promise<unknown>;
15
+ private controlOne;
16
+ private startProcess;
17
+ private startTransfer;
18
+ private restoreTransfer;
19
+ private tcp;
20
+ private startForward;
21
+ disconnect(owner: string): Promise<void>;
22
+ abandon(task: AtomicTask, owner: string): Promise<void>;
23
+ revoke(owner?: string): Promise<void>;
24
+ listLocal(): Record<string, unknown>[];
25
+ localInput(id: string, value: Buffer): Promise<void>;
26
+ renewCredential(id: string): string;
27
+ get hasRetained(): boolean;
28
+ }
@@ -0,0 +1,427 @@
1
+ import { spawn as spawnProcess } from 'node:child_process';
2
+ import { createHash, randomBytes, randomUUID, timingSafeEqual } from 'node:crypto';
3
+ import { constants } from 'node:fs';
4
+ import { open, lstat, realpath, rename, unlink } from 'node:fs/promises';
5
+ import { dirname, resolve, join, basename } from 'node:path';
6
+ import net from 'node:net';
7
+ import { Journal } from './journal.js';
8
+ import { killTree } from './executor.js';
9
+ import { sha256 } from './util.js';
10
+ import { preparePty } from './prepare-pty.js';
11
+ const supported = new Set(['process.open', 'file.transfer', 'resource.resume', 'net.forward']);
12
+ export const resourceOperation = (operation) => supported.has(operation);
13
+ const publicMeta = (meta) => Object.fromEntries(Object.entries(meta).filter(([key]) => !['tokenHash', 'temp', 'parent', 'beforeSha256', 'mode'].includes(key)));
14
+ async function fileHash(path) { const file = await open(path, constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0)); try {
15
+ const hash = createHash('sha256');
16
+ for await (const chunk of file.createReadStream({ autoClose: false }))
17
+ hash.update(chunk);
18
+ return hash.digest('hex');
19
+ }
20
+ finally {
21
+ await file.close();
22
+ } }
23
+ async function currentHash(path) { try {
24
+ const stat = await lstat(path);
25
+ if (!stat.isFile() || stat.isSymbolicLink())
26
+ throw new Error('Target must be a regular, non-symlink file');
27
+ return await fileHash(path);
28
+ }
29
+ catch (error) {
30
+ if (error.code === 'ENOENT')
31
+ return null;
32
+ throw error;
33
+ } }
34
+ export class SessionResources {
35
+ audit;
36
+ journal;
37
+ resources = new Map();
38
+ writes = new Map();
39
+ constructor(root, audit) {
40
+ this.audit = audit;
41
+ this.journal = new Journal(root);
42
+ }
43
+ setAudit(audit) { this.audit = audit; }
44
+ create(id, kind, owner, retainOnDisconnect, details = {}) {
45
+ if (this.resources.has(id) || this.journal.exists(id))
46
+ throw new Error('Resource ID already exists. Resume it; do not replay its creation.');
47
+ if ([...this.resources.values()].filter(r => ['running', 'open', 'listening'].includes(r.meta.state)).length >= 128)
48
+ throw new Error('Active resource limit reached; close unused resources');
49
+ const token = randomBytes(32).toString('base64url'), now = new Date().toISOString();
50
+ const meta = { id, kind, state: 'open', createdAt: now, updatedAt: now, ownerPid: process.pid, tokenHash: sha256(Buffer.from(token)), retainOnDisconnect, ...details };
51
+ const resource = { meta, owner, close: () => { meta.state = 'closed'; this.journal.save(meta); } };
52
+ this.resources.set(id, resource);
53
+ this.journal.save(meta);
54
+ return { resource, token };
55
+ }
56
+ async open(task, owner, signal) {
57
+ signal?.throwIfAborted();
58
+ if (task.operation === 'process.open')
59
+ return this.startProcess(task, owner, signal);
60
+ if (task.operation === 'file.transfer')
61
+ return this.startTransfer(task, owner, signal);
62
+ if (task.operation === 'net.forward')
63
+ return this.startForward(task, owner, signal);
64
+ if (task.operation === 'resource.resume') {
65
+ const { id, resumeToken } = task.arguments;
66
+ let resource = this.resources.get(id);
67
+ const meta = resource?.meta ?? this.journal.load(id);
68
+ if (!timingSafeEqual(Buffer.from(meta.tokenHash, 'hex'), createHash('sha256').update(resumeToken).digest()))
69
+ throw new Error('Invalid resource recovery credential');
70
+ if (!resource) {
71
+ if (meta.kind === 'upload' || meta.kind === 'download')
72
+ resource = await this.restoreTransfer(meta, owner);
73
+ else if (meta.kind === 'process') {
74
+ if (meta.state === 'running') {
75
+ meta.state = 'interrupted';
76
+ meta.recoveryNote = 'Original host process is unavailable here. Stored output is recoverable; the command is never replayed.';
77
+ this.journal.save(meta);
78
+ }
79
+ resource = { meta, owner, close: () => { } };
80
+ }
81
+ else
82
+ throw new Error('Network connections cannot survive host restart; create a new forward');
83
+ this.resources.set(id, resource);
84
+ }
85
+ if (signal?.aborted) {
86
+ await resource.close();
87
+ signal.throwIfAborted();
88
+ }
89
+ resource.owner = owner;
90
+ this.audit.record('resource.resumed', { id, kind: meta.kind });
91
+ return publicMeta(meta);
92
+ }
93
+ throw new Error('Unsupported resource operation');
94
+ }
95
+ async control(owner, request) {
96
+ if (request.id && ['input', 'commit'].includes(request.action)) {
97
+ const id = request.id, result = (this.writes.get(id) ?? Promise.resolve()).catch(() => { }).then(() => this.controlOne(owner, request));
98
+ this.writes.set(id, result);
99
+ void result.finally(() => { if (this.writes.get(id) === result)
100
+ this.writes.delete(id); }).catch(() => { });
101
+ return result;
102
+ }
103
+ return this.controlOne(owner, request);
104
+ }
105
+ async controlOne(owner, request) {
106
+ if (request.action === 'list')
107
+ return { resources: [...this.resources.values()].filter(r => r.owner === owner).map(r => publicMeta(r.meta)) };
108
+ const resource = this.resources.get(request.id ?? '');
109
+ if (!resource || resource.owner !== owner)
110
+ throw new Error('Resource is not attached to this connection. Resume it with its ID and recovery credential first.');
111
+ const { meta } = resource;
112
+ if (request.action === 'status')
113
+ return publicMeta(meta);
114
+ if (request.action === 'read') {
115
+ const stored = resource.read ? undefined : this.journal.read(meta.id, request.cursor, request.limit);
116
+ const value = resource.read ? await resource.read(request) : { ...stored, resource: publicMeta(meta), ended: meta.state !== 'running' && !stored.hasMore };
117
+ if (resource.owner !== owner)
118
+ throw new Error('Resource authorization was revoked');
119
+ this.audit.record('resource.read-sending', { id: meta.id, kind: meta.kind, cursor: request.cursor, responseBytes: Buffer.byteLength(JSON.stringify(value)) });
120
+ return value;
121
+ }
122
+ if (request.action !== 'close' && !['running', 'open', 'listening'].includes(meta.state))
123
+ throw new Error('Resource has finished or closed; only status/read are available');
124
+ if (request.action === 'input') {
125
+ if (!resource.input)
126
+ throw new Error('This resource does not accept input');
127
+ const bytes = Buffer.from(request.data ?? '', 'base64');
128
+ if (bytes.length > 65536 || bytes.toString('base64') !== (request.data ?? ''))
129
+ throw new Error('Invalid input encoding');
130
+ this.audit.record('resource.input', { id: meta.id, bytes: bytes.length, eof: request.eof });
131
+ await resource.input(bytes, request.eof);
132
+ return { acceptedBytes: bytes.length };
133
+ }
134
+ if (request.action === 'resize') {
135
+ if (!resource.resize || !request.cols || !request.rows)
136
+ throw new Error('Resize requires a PTY and dimensions');
137
+ this.audit.record('resource.resize', { id: meta.id, cols: request.cols, rows: request.rows });
138
+ resource.resize(request.cols, request.rows);
139
+ return publicMeta(meta);
140
+ }
141
+ if (request.action === 'signal') {
142
+ if (!resource.signal)
143
+ throw new Error('Not a running process');
144
+ const signal = request.signal ?? 'SIGINT';
145
+ this.audit.record('resource.signal', { id: meta.id, signal });
146
+ resource.signal(signal);
147
+ return { signalled: true };
148
+ }
149
+ if (request.action === 'close') {
150
+ this.audit.record('resource.close', { id: meta.id });
151
+ await resource.close();
152
+ return publicMeta(meta);
153
+ }
154
+ if (resource.control)
155
+ return resource.control(request);
156
+ throw new Error('Unsupported resource action');
157
+ }
158
+ async startProcess(task, owner, signal) {
159
+ const args = task.arguments, executable = args.executable ?? (process.platform === 'win32' ? process.env.ComSpec ?? 'cmd.exe' : process.env.SHELL ?? '/bin/sh');
160
+ const { resource, token } = this.create(task.id, 'process', owner, args.retainOnDisconnect, { state: 'running', executable, cwd: resolve(args.cwd ?? process.cwd()), pty: args.pty, cols: args.cols, rows: args.rows, bytes: 0 });
161
+ const { meta } = resource;
162
+ const env = { ...process.env, ...args.env };
163
+ for (const key of Object.keys(env))
164
+ if (/^(?:DIAGNOSE_|OWON_|NPM_TOKEN|NODE_AUTH_TOKEN)/i.test(key))
165
+ delete env[key];
166
+ let timer, force, closing = false;
167
+ const ended = (code, signal) => { clearTimeout(timer); clearTimeout(force); meta.state = 'exited'; meta.exitCode = code; if (signal !== undefined)
168
+ meta.signal = signal; this.journal.save(meta); this.audit.record('resource.process-exited', { id: meta.id, exitCode: code }); };
169
+ const collect = (stream, bytes) => {
170
+ try {
171
+ const keep = Math.max(0, Math.min(bytes.length, args.maxOutputBytes - Number(meta.bytes)));
172
+ if (keep)
173
+ this.journal.append(meta.id, stream, bytes.subarray(0, keep));
174
+ meta.bytes = Number(meta.bytes) + keep;
175
+ if (keep < bytes.length) {
176
+ meta.truncated = true;
177
+ resource.signal?.('SIGKILL');
178
+ }
179
+ }
180
+ catch (error) {
181
+ meta.error = error.message;
182
+ resource.signal?.('SIGKILL');
183
+ }
184
+ };
185
+ try {
186
+ if (args.pty) {
187
+ await preparePty();
188
+ const pty = await import('node-pty');
189
+ signal?.throwIfAborted();
190
+ if (resource.owner !== owner)
191
+ throw new Error('Resource authorization was revoked');
192
+ const child = pty.spawn(executable, args.args, { name: 'xterm-256color', cols: args.cols, rows: args.rows, cwd: String(meta.cwd), env, encoding: null });
193
+ meta.pid = child.pid;
194
+ child.onData(value => collect('terminal', Buffer.isBuffer(value) ? value : Buffer.from(value)));
195
+ child.onExit(value => ended(value.exitCode, value.signal));
196
+ resource.input = async (bytes, eof) => { child.write(bytes.toString('utf8')); if (eof)
197
+ child.write('\x04'); };
198
+ resource.resize = (cols, rows) => { child.resize(cols, rows); meta.cols = cols; meta.rows = rows; this.journal.save(meta); };
199
+ resource.signal = signal => { try {
200
+ child.kill(signal);
201
+ }
202
+ catch { } };
203
+ }
204
+ else {
205
+ const child = spawnProcess(executable, args.args, { cwd: String(meta.cwd), env, detached: process.platform !== 'win32', stdio: ['pipe', 'pipe', 'pipe'], windowsHide: true });
206
+ meta.pid = child.pid;
207
+ child.stdout.on('data', bytes => collect('stdout', bytes));
208
+ child.stderr.on('data', bytes => collect('stderr', bytes));
209
+ child.stdin.on('error', () => { });
210
+ child.on('error', error => { meta.error = error.message; });
211
+ child.on('close', (code, signal) => ended(code, signal ?? undefined));
212
+ resource.input = (bytes, eof) => new Promise((resolveInput, reject) => { if (child.stdin.destroyed || child.stdin.writableEnded) {
213
+ reject(new Error('Process stdin is closed'));
214
+ return;
215
+ } if (eof)
216
+ child.stdin.end(bytes, resolveInput);
217
+ else
218
+ child.stdin.write(bytes, error => error ? reject(error) : resolveInput()); });
219
+ resource.signal = signal => { if (process.platform === 'win32')
220
+ killTree(child, signal === 'SIGKILL');
221
+ else {
222
+ try {
223
+ process.kill(-child.pid, signal);
224
+ }
225
+ catch { }
226
+ } };
227
+ }
228
+ resource.close = () => { if (meta.state === 'running' && !closing) {
229
+ closing = true;
230
+ resource.signal?.('SIGTERM');
231
+ force = setTimeout(() => resource.signal?.('SIGKILL'), 1000);
232
+ force.unref();
233
+ } };
234
+ if (args.timeoutMs) {
235
+ timer = setTimeout(() => { meta.timedOut = true; void resource.close(); }, args.timeoutMs);
236
+ timer.unref();
237
+ }
238
+ this.journal.save(meta);
239
+ this.audit.record('resource.process-started', { id: meta.id, pid: meta.pid, pty: args.pty, retainOnDisconnect: args.retainOnDisconnect });
240
+ return { ...publicMeta(meta), resumeToken: token, output: 'Raw, unredacted bytes. Poll read from cursor 0 for live output; input/resize/signals are authorized for this handle.' };
241
+ }
242
+ catch (error) {
243
+ meta.state = 'failed';
244
+ meta.error = error.message;
245
+ this.journal.save(meta);
246
+ throw error;
247
+ }
248
+ }
249
+ async startTransfer(task, owner, signal) {
250
+ const args = task.arguments, path = resolve(args.path);
251
+ let details;
252
+ if (args.direction === 'download') {
253
+ const stat = await lstat(path);
254
+ if (!stat.isFile() || stat.isSymbolicLink())
255
+ throw new Error('Download requires a regular non-symlink file');
256
+ details = { path, size: stat.size, sha256: await fileHash(path), offset: 0 };
257
+ }
258
+ else {
259
+ if (args.size === undefined || !args.sha256)
260
+ throw new Error('Upload requires exact size and SHA-256');
261
+ const before = await currentHash(path);
262
+ if (before !== null && !args.overwrite)
263
+ throw new Error('Target exists; explicit overwrite authorization required');
264
+ details = { path, parent: await realpath(dirname(path)), temp: join(dirname(path), `.${basename(path)}.diagnose-${task.id}`), beforeSha256: before, size: args.size, sha256: args.sha256, offset: 0 };
265
+ }
266
+ signal?.throwIfAborted();
267
+ const { resource, token } = this.create(task.id, args.direction, owner, args.retainOnDisconnect, details);
268
+ const live = await this.restoreTransfer(resource.meta, owner, true);
269
+ if (signal?.aborted || resource.owner !== owner) {
270
+ await live.close();
271
+ throw new Error('Transfer authorization was cancelled');
272
+ }
273
+ this.resources.set(task.id, live);
274
+ this.audit.record('resource.transfer-opened', { id: task.id, direction: args.direction, path, size: details.size });
275
+ return { ...publicMeta(live.meta), resumeToken: token, encoding: 'base64', redaction: 'none; exact file bytes' };
276
+ }
277
+ async restoreTransfer(meta, owner, fresh = false) {
278
+ if (meta.state !== 'open')
279
+ return { meta, owner, close: () => { } };
280
+ const upload = meta.kind === 'upload';
281
+ if (upload && await realpath(dirname(String(meta.path))) !== meta.parent)
282
+ throw new Error('Transfer parent changed');
283
+ const file = await open(String(upload ? meta.temp : meta.path), upload ? fresh ? 'wx+' : constants.O_RDWR | (constants.O_NOFOLLOW ?? 0) : constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0), 0o600);
284
+ if (upload && !fresh && (await file.stat()).size !== meta.offset) {
285
+ await file.close();
286
+ throw new Error('Partial upload size changed');
287
+ }
288
+ let closed = false;
289
+ const resource = { meta, owner, close: async () => { if (!closed) {
290
+ closed = true;
291
+ await file.close();
292
+ } if (upload)
293
+ await unlink(String(meta.temp)).catch(() => { }); meta.state = 'closed'; this.journal.save(meta); } };
294
+ if (!upload)
295
+ resource.read = async (request) => { const bytes = Buffer.alloc(Math.min(request.limit, Math.max(0, Number(meta.size) - request.cursor))); const read = await file.read(bytes, 0, bytes.length, request.cursor); return { data: bytes.subarray(0, read.bytesRead).toString('base64'), offset: request.cursor, nextOffset: request.cursor + read.bytesRead, ended: request.cursor + read.bytesRead >= Number(meta.size), size: meta.size, sha256: meta.sha256 }; };
296
+ else {
297
+ resource.input = async (bytes) => { if (closed)
298
+ throw new Error('Upload closed'); if (Number(meta.offset) + bytes.length > Number(meta.size))
299
+ throw new Error('Upload exceeds declared size'); let written = 0; while (written < bytes.length) {
300
+ const result = await file.write(bytes, written, bytes.length - written, Number(meta.offset) + written);
301
+ if (!result.bytesWritten)
302
+ throw new Error('Upload write made no progress');
303
+ written += result.bytesWritten;
304
+ } meta.offset = Number(meta.offset) + bytes.length; this.journal.save(meta); };
305
+ resource.control = async (request) => {
306
+ if (request.action !== 'commit')
307
+ throw new Error('Unsupported transfer action');
308
+ if (meta.offset !== meta.size)
309
+ throw new Error('Upload is incomplete');
310
+ await file.sync();
311
+ if (await fileHash(String(meta.temp)) !== meta.sha256)
312
+ throw new Error('Upload SHA-256 mismatch; destination untouched');
313
+ if (await realpath(dirname(String(meta.path))) !== meta.parent || await currentHash(String(meta.path)) !== meta.beforeSha256)
314
+ throw new Error('Destination changed since upload authorization');
315
+ await file.close();
316
+ closed = true;
317
+ await rename(String(meta.temp), String(meta.path));
318
+ meta.state = 'committed';
319
+ this.journal.save(meta);
320
+ this.audit.record('resource.file-changed', { id: meta.id, path: meta.path, beforeSha256: meta.beforeSha256, afterSha256: meta.sha256, bytes: meta.size });
321
+ return publicMeta(meta);
322
+ };
323
+ }
324
+ return resource;
325
+ }
326
+ tcp(socket, owner, parentId) {
327
+ const { resource } = this.create(randomUUID(), 'tcp', owner, false, { parentId, state: 'open', bytesRead: 0, bytesWritten: 0 });
328
+ let chunks = [], size = 0, ended = false;
329
+ socket.on('data', chunk => { chunks.push(Buffer.from(chunk)); size += chunk.length; resource.meta.bytesRead = Number(resource.meta.bytesRead) + chunk.length; if (size > 256 * 1024)
330
+ socket.pause(); });
331
+ socket.on('end', () => { ended = true; });
332
+ socket.on('close', () => { ended = true; resource.meta.state = 'closed'; this.journal.save(resource.meta); });
333
+ socket.on('error', error => { resource.meta.error = error.message; ended = true; });
334
+ resource.read = async (request) => { const count = Math.min(size, request.limit), result = Buffer.alloc(count); let offset = 0; while (offset < count) {
335
+ const chunk = chunks[0], keep = Math.min(chunk.length, count - offset);
336
+ chunk.copy(result, offset, 0, keep);
337
+ if (keep === chunk.length)
338
+ chunks.shift();
339
+ else
340
+ chunks[0] = chunk.subarray(keep);
341
+ offset += keep;
342
+ } size -= count; if (size < 128 * 1024 && !ended)
343
+ socket.resume(); return { data: result.toString('base64'), ended: ended && size === 0 }; };
344
+ resource.input = (bytes, eof) => new Promise((resolveInput, reject) => { if (socket.destroyed) {
345
+ reject(new Error('TCP connection closed'));
346
+ return;
347
+ } resource.meta.bytesWritten = Number(resource.meta.bytesWritten) + bytes.length; if (eof)
348
+ socket.end(bytes, resolveInput);
349
+ else
350
+ socket.write(bytes, error => error ? reject(error) : resolveInput()); });
351
+ resource.close = () => { chunks = []; size = 0; socket.destroy(); };
352
+ return resource;
353
+ }
354
+ async startForward(task, owner, signal) {
355
+ const args = task.arguments;
356
+ if (args.direction !== 'socks' && !args.port)
357
+ throw new Error('A fixed target port is required');
358
+ const { resource, token } = this.create(task.id, 'forward', owner, false, { ...args, state: args.direction === 'remote' ? 'listening' : 'open' });
359
+ let server;
360
+ const pending = [];
361
+ if (args.direction === 'remote') {
362
+ server = net.createServer({ allowHalfOpen: true }, socket => { if (signal?.aborted || resource.owner !== owner || pending.length >= 32) {
363
+ socket.destroy();
364
+ return;
365
+ } try {
366
+ pending.push(this.tcp(socket, resource.owner, task.id).meta.id);
367
+ }
368
+ catch {
369
+ socket.destroy();
370
+ } });
371
+ server.on('error', error => { resource.meta.error = error.message; });
372
+ await new Promise((resolveListen, reject) => { server.once('error', reject); server.listen(args.bindPort, args.bindHost, () => { server.off('error', reject); resolveListen(); }); });
373
+ resource.meta.listeningPort = server.address().port;
374
+ }
375
+ if (signal?.aborted || resource.owner !== owner) {
376
+ server?.close();
377
+ resource.meta.state = 'closed';
378
+ this.journal.save(resource.meta);
379
+ throw new Error('Forward authorization was cancelled');
380
+ }
381
+ resource.control = async (request) => {
382
+ if (request.action === 'accept' && server)
383
+ return { connections: pending.splice(0, 16) };
384
+ if (request.action !== 'connect' || server)
385
+ throw new Error('Unsupported forwarding action');
386
+ const host = args.direction === 'socks' ? request.host : args.host, port = args.direction === 'socks' ? request.port : args.port;
387
+ if (!host || !port || (args.direction === 'socks' && !args.allowedHosts.includes('*') && !args.allowedHosts.includes(host)))
388
+ throw new Error('Destination is outside the authorized forwarding scope');
389
+ const socket = net.createConnection({ host, port, allowHalfOpen: true });
390
+ await new Promise((resolveConnect, reject) => { socket.once('connect', resolveConnect); socket.once('error', reject); socket.setTimeout(10000, () => socket.destroy(new Error('TCP connect timeout'))); });
391
+ socket.setTimeout(0);
392
+ if (resource.owner !== owner || resource.meta.state === 'closed') {
393
+ socket.destroy();
394
+ throw new Error('Forward authorization was revoked');
395
+ }
396
+ const child = this.tcp(socket, resource.owner, task.id);
397
+ this.audit.record('resource.tcp-connected', { id: child.meta.id, parentId: task.id, host, port });
398
+ return publicMeta(child.meta);
399
+ };
400
+ resource.close = async () => { server?.close(); for (const child of this.resources.values())
401
+ if (child.meta.parentId === task.id)
402
+ await child.close(); resource.meta.state = 'closed'; this.journal.save(resource.meta); };
403
+ this.journal.save(resource.meta);
404
+ return { ...publicMeta(resource.meta), resumeToken: token };
405
+ }
406
+ async disconnect(owner) { for (const resource of this.resources.values())
407
+ if (resource.owner === owner) {
408
+ resource.owner = '';
409
+ if (!resource.meta.retainOnDisconnect)
410
+ await resource.close();
411
+ } }
412
+ async abandon(task, owner) { const id = task.operation === 'resource.resume' ? task.arguments.id : task.id, resource = this.resources.get(id); if (resource?.owner === owner) {
413
+ resource.owner = '';
414
+ if (task.operation !== 'resource.resume' || !resource.meta.retainOnDisconnect)
415
+ await resource.close();
416
+ } }
417
+ async revoke(owner) { for (const resource of this.resources.values())
418
+ if (owner === undefined || resource.owner === owner) {
419
+ resource.owner = '';
420
+ await resource.close();
421
+ } }
422
+ listLocal() { return [...this.resources.values()].map(resource => publicMeta(resource.meta)); }
423
+ async localInput(id, value) { const resource = this.resources.get(id); if (!resource?.input || resource.meta.state !== 'running')
424
+ throw new Error('No live process with this ID'); this.audit.record('resource.local-input', { id, bytes: value.length }); await resource.input(value, false); }
425
+ renewCredential(id) { const meta = this.resources.get(id)?.meta ?? this.journal.load(id); const token = randomBytes(32).toString('base64url'); meta.tokenHash = sha256(Buffer.from(token)); this.journal.save(meta); this.audit.record('resource.local-credential-renewed', { id }); return token; }
426
+ get hasRetained() { return [...this.resources.values()].some(r => r.meta.retainOnDisconnect && ['running', 'open'].includes(r.meta.state)); }
427
+ }