@clagentic/console 1.0.4 → 1.1.0-beta.1
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/lib/audit.js +57 -0
- package/lib/config.js +11 -11
- package/lib/os-users.js +5 -0
- package/lib/project-connection.js +12 -2
- package/lib/project-loop.js +30 -23
- package/lib/project-notifications.js +5 -0
- package/lib/project-user-message.js +38 -9
- package/lib/project.js +26 -2
- package/lib/public/app.js +3 -2
- package/lib/public/modules/app-messages.js +8 -0
- package/lib/public/modules/app-projects.js +7 -0
- package/lib/public/modules/markdown.js +5 -2
- package/lib/public/modules/sidebar-mobile.js +2 -3
- package/lib/public/modules/sidebar-sessions.js +9 -0
- package/lib/push.js +14 -16
- package/lib/sdk-bridge.js +21 -4
- package/lib/sdk-message-processor.js +16 -4
- package/lib/sdk-message-queue.js +6 -8
- package/lib/sdk-worker.js +45 -13
- package/lib/server-admin.js +69 -0
- package/lib/server-auth.js +129 -15
- package/lib/server-settings.js +5 -0
- package/lib/server.js +1 -0
- package/lib/sessions.js +264 -38
- package/lib/store.js +137 -0
- package/lib/terminal-manager.js +56 -11
- package/lib/users.js +11 -4
- package/lib/yoke/adapters/claude-worker.js +44 -13
- package/package.json +1 -1
package/lib/sdk-bridge.js
CHANGED
|
@@ -369,13 +369,19 @@ function createSDKBridge(opts) {
|
|
|
369
369
|
});
|
|
370
370
|
|
|
371
371
|
if (pushModule) {
|
|
372
|
-
|
|
372
|
+
var _elicitPayload = {
|
|
373
373
|
type: "elicitation",
|
|
374
374
|
slug: slug,
|
|
375
375
|
title: (request.serverName || "MCP Server") + " needs input",
|
|
376
376
|
body: request.message || "Waiting for your response",
|
|
377
377
|
tag: "claude-elicitation",
|
|
378
|
-
}
|
|
378
|
+
};
|
|
379
|
+
// Route to session owner only — body carries MCP message text.
|
|
380
|
+
if (usersModule.isMultiUser() && session.ownerId && pushModule.sendPushToUser) {
|
|
381
|
+
pushModule.sendPushToUser(session.ownerId, _elicitPayload);
|
|
382
|
+
} else {
|
|
383
|
+
pushModule.sendPush(_elicitPayload);
|
|
384
|
+
}
|
|
379
385
|
}
|
|
380
386
|
|
|
381
387
|
if (opts.signal) {
|
|
@@ -619,13 +625,19 @@ function createSDKBridge(opts) {
|
|
|
619
625
|
onProcessingChanged(); // update cross-project permission badge
|
|
620
626
|
|
|
621
627
|
if (pushModule) {
|
|
622
|
-
|
|
628
|
+
var _permPayload = {
|
|
623
629
|
type: "permission_request",
|
|
624
630
|
slug: slug,
|
|
625
631
|
requestId: requestId,
|
|
626
632
|
title: permissionPushTitle(toolName, input),
|
|
627
633
|
body: permissionPushBody(toolName, input),
|
|
628
|
-
}
|
|
634
|
+
};
|
|
635
|
+
// Route to session owner only — body carries tool name and input (may contain paths/code).
|
|
636
|
+
if (usersModule.isMultiUser() && session.ownerId && pushModule.sendPushToUser) {
|
|
637
|
+
pushModule.sendPushToUser(session.ownerId, _permPayload);
|
|
638
|
+
} else {
|
|
639
|
+
pushModule.sendPush(_permPayload);
|
|
640
|
+
}
|
|
629
641
|
}
|
|
630
642
|
|
|
631
643
|
var _nm = getNotificationsModule();
|
|
@@ -1343,6 +1355,9 @@ function createSDKBridge(opts) {
|
|
|
1343
1355
|
|
|
1344
1356
|
session.lastActivityAt = Date.now();
|
|
1345
1357
|
session.streamPromise = processQueryStream(session).catch(function(err) {
|
|
1358
|
+
console.error("[sdk-bridge] Unhandled stream error for session " + session.localId + ":", err && err.message || err);
|
|
1359
|
+
sendToSession(session, { type: "error", text: "Stream error: " + (err && err.message || String(err)) });
|
|
1360
|
+
sendToSession(session, { type: "done", code: 1 });
|
|
1346
1361
|
});
|
|
1347
1362
|
}
|
|
1348
1363
|
|
|
@@ -1405,6 +1420,8 @@ function createSDKBridge(opts) {
|
|
|
1405
1420
|
var result = [];
|
|
1406
1421
|
|
|
1407
1422
|
function tryLookup(name) {
|
|
1423
|
+
// name MUST be a value from the allowlist below — shell injection risk if dynamic
|
|
1424
|
+
if (!["claude", "codex"].includes(name)) throw new Error("Disallowed binary name: " + name);
|
|
1408
1425
|
try {
|
|
1409
1426
|
if (linuxUser) {
|
|
1410
1427
|
execFileSync("su", ["-", linuxUser, "-c", "which " + name], { timeout: 3000, stdio: ["pipe", "pipe", "pipe"] });
|
|
@@ -278,13 +278,19 @@ function attachMessageProcessor(ctx) {
|
|
|
278
278
|
|
|
279
279
|
if (pushModule && block.name === "AskUserQuestion" && input.questions) {
|
|
280
280
|
var q = input.questions[0];
|
|
281
|
-
|
|
281
|
+
var _askPayload = {
|
|
282
282
|
type: "ask_user",
|
|
283
283
|
slug: slug,
|
|
284
284
|
title: "Claude has a question",
|
|
285
285
|
body: q ? q.question : "Waiting for your response",
|
|
286
286
|
tag: "claude-ask",
|
|
287
|
-
}
|
|
287
|
+
};
|
|
288
|
+
// Route to session owner only — content carries prompt text.
|
|
289
|
+
if (usersModule.isMultiUser() && session.ownerId && pushModule.sendPushToUser) {
|
|
290
|
+
pushModule.sendPushToUser(session.ownerId, _askPayload);
|
|
291
|
+
} else {
|
|
292
|
+
pushModule.sendPush(_askPayload);
|
|
293
|
+
}
|
|
288
294
|
}
|
|
289
295
|
} else if (block && block.type === "thinking") {
|
|
290
296
|
var duration = block.startTime ? (Date.now() - block.startTime) / 1000 : 0;
|
|
@@ -500,13 +506,19 @@ function attachMessageProcessor(ctx) {
|
|
|
500
506
|
var _doneTitle = session.title || "Claude";
|
|
501
507
|
|
|
502
508
|
if (pushModule) {
|
|
503
|
-
|
|
509
|
+
var _donePayload = {
|
|
504
510
|
type: "done",
|
|
505
511
|
slug: slug,
|
|
506
512
|
title: _doneTitle,
|
|
507
513
|
body: _donePreviewText || "Response ready",
|
|
508
514
|
tag: "claude-done",
|
|
509
|
-
}
|
|
515
|
+
};
|
|
516
|
+
// Route to session owner only — body carries response preview text.
|
|
517
|
+
if (usersModule.isMultiUser() && session.ownerId && pushModule.sendPushToUser) {
|
|
518
|
+
pushModule.sendPushToUser(session.ownerId, _donePayload);
|
|
519
|
+
} else {
|
|
520
|
+
pushModule.sendPush(_donePayload);
|
|
521
|
+
}
|
|
510
522
|
}
|
|
511
523
|
|
|
512
524
|
var _nm = getNotificationsModule();
|
package/lib/sdk-message-queue.js
CHANGED
|
@@ -1,13 +1,12 @@
|
|
|
1
1
|
// Async message queue for streaming input to SDK
|
|
2
2
|
function createMessageQueue() {
|
|
3
3
|
var queue = [];
|
|
4
|
-
var
|
|
4
|
+
var waitingResolvers = [];
|
|
5
5
|
var ended = false;
|
|
6
6
|
return {
|
|
7
7
|
push: function(msg) {
|
|
8
|
-
if (
|
|
9
|
-
var resolve =
|
|
10
|
-
waiting = null;
|
|
8
|
+
if (waitingResolvers.length > 0) {
|
|
9
|
+
var resolve = waitingResolvers.shift();
|
|
11
10
|
resolve({ value: msg, done: false });
|
|
12
11
|
} else {
|
|
13
12
|
queue.push(msg);
|
|
@@ -15,9 +14,8 @@ function createMessageQueue() {
|
|
|
15
14
|
},
|
|
16
15
|
end: function() {
|
|
17
16
|
ended = true;
|
|
18
|
-
|
|
19
|
-
var resolve =
|
|
20
|
-
waiting = null;
|
|
17
|
+
while (waitingResolvers.length > 0) {
|
|
18
|
+
var resolve = waitingResolvers.shift();
|
|
21
19
|
resolve({ value: undefined, done: true });
|
|
22
20
|
}
|
|
23
21
|
},
|
|
@@ -31,7 +29,7 @@ function createMessageQueue() {
|
|
|
31
29
|
return Promise.resolve({ value: undefined, done: true });
|
|
32
30
|
}
|
|
33
31
|
return new Promise(function(resolve) {
|
|
34
|
-
|
|
32
|
+
waitingResolvers.push(resolve);
|
|
35
33
|
});
|
|
36
34
|
},
|
|
37
35
|
};
|
package/lib/sdk-worker.js
CHANGED
|
@@ -20,6 +20,8 @@ try { require("fs").writeSync(2, "[sdk-worker] BOOT pid=" + process.pid + " uid=
|
|
|
20
20
|
var net = require("net");
|
|
21
21
|
var crypto = require("crypto");
|
|
22
22
|
var path = require("path");
|
|
23
|
+
var fs = require("fs");
|
|
24
|
+
var os = require("os");
|
|
23
25
|
|
|
24
26
|
var socketPath = process.argv[2];
|
|
25
27
|
if (!socketPath) {
|
|
@@ -42,13 +44,12 @@ var buffer = "";
|
|
|
42
44
|
// --- Message queue (same implementation as sdk-bridge.js) ---
|
|
43
45
|
function createMessageQueue() {
|
|
44
46
|
var queue = [];
|
|
45
|
-
var
|
|
47
|
+
var waitingResolvers = [];
|
|
46
48
|
var ended = false;
|
|
47
49
|
return {
|
|
48
50
|
push: function(msg) {
|
|
49
|
-
if (
|
|
50
|
-
var resolve =
|
|
51
|
-
waiting = null;
|
|
51
|
+
if (waitingResolvers.length > 0) {
|
|
52
|
+
var resolve = waitingResolvers.shift();
|
|
52
53
|
resolve({ value: msg, done: false });
|
|
53
54
|
} else {
|
|
54
55
|
queue.push(msg);
|
|
@@ -56,9 +57,8 @@ function createMessageQueue() {
|
|
|
56
57
|
},
|
|
57
58
|
end: function() {
|
|
58
59
|
ended = true;
|
|
59
|
-
|
|
60
|
-
var resolve =
|
|
61
|
-
waiting = null;
|
|
60
|
+
while (waitingResolvers.length > 0) {
|
|
61
|
+
var resolve = waitingResolvers.shift();
|
|
62
62
|
resolve({ value: undefined, done: true });
|
|
63
63
|
}
|
|
64
64
|
},
|
|
@@ -72,7 +72,7 @@ function createMessageQueue() {
|
|
|
72
72
|
return Promise.resolve({ value: undefined, done: true });
|
|
73
73
|
}
|
|
74
74
|
return new Promise(function(resolve) {
|
|
75
|
-
|
|
75
|
+
waitingResolvers.push(resolve);
|
|
76
76
|
});
|
|
77
77
|
},
|
|
78
78
|
};
|
|
@@ -158,11 +158,23 @@ function canUseTool(toolName, input, opts) {
|
|
|
158
158
|
decisionReason: opts.decisionReason || "",
|
|
159
159
|
});
|
|
160
160
|
return new Promise(function(resolve) {
|
|
161
|
-
|
|
161
|
+
var timeoutId = setTimeout(function() {
|
|
162
|
+
if (pendingPermissions[requestId]) {
|
|
163
|
+
delete pendingPermissions[requestId];
|
|
164
|
+
resolve({ behavior: "deny", message: "Permission request timed out after 30s" });
|
|
165
|
+
}
|
|
166
|
+
}, 30000);
|
|
167
|
+
pendingPermissions[requestId] = function(result) {
|
|
168
|
+
clearTimeout(timeoutId);
|
|
169
|
+
resolve(result);
|
|
170
|
+
};
|
|
162
171
|
if (opts.signal) {
|
|
163
172
|
opts.signal.addEventListener("abort", function() {
|
|
164
|
-
|
|
165
|
-
|
|
173
|
+
if (pendingPermissions[requestId]) {
|
|
174
|
+
clearTimeout(timeoutId);
|
|
175
|
+
delete pendingPermissions[requestId];
|
|
176
|
+
resolve({ behavior: "deny", message: "Cancelled" });
|
|
177
|
+
}
|
|
166
178
|
});
|
|
167
179
|
}
|
|
168
180
|
});
|
|
@@ -354,8 +366,15 @@ async function handleQueryStart(msg) {
|
|
|
354
366
|
var options = msg.options || {};
|
|
355
367
|
if (_mcpServers) options.mcpServers = _mcpServers;
|
|
356
368
|
options.abortController = abortController;
|
|
357
|
-
|
|
358
|
-
|
|
369
|
+
if (process.env.CLAGENTIC_DEBUG === "1") {
|
|
370
|
+
var _logDir = path.join(os.homedir(), ".clagentic", "worker-logs");
|
|
371
|
+
fs.mkdirSync(_logDir, { recursive: true, mode: 0o700 });
|
|
372
|
+
var _logFile = path.join(_logDir, process.pid + ".log");
|
|
373
|
+
// Create with 0o600 before passing to the SDK so the file is never world-readable
|
|
374
|
+
fs.writeFileSync(_logFile, "", { flag: "a", mode: 0o600 });
|
|
375
|
+
options.debug = true;
|
|
376
|
+
options.debugFile = _logFile;
|
|
377
|
+
}
|
|
359
378
|
// Override CLI subprocess spawn to inject NODE_OPTIONS for IPv4-first DNS.
|
|
360
379
|
// The SDK constructs its own env for the CLI process, so worker env vars
|
|
361
380
|
// like NODE_OPTIONS are not inherited. We intercept the spawn to fix this.
|
|
@@ -492,12 +511,25 @@ async function handleQueryStart(msg) {
|
|
|
492
511
|
stderr: err.stderr || null,
|
|
493
512
|
});
|
|
494
513
|
} finally {
|
|
514
|
+
for (var k in pendingPermissions) {
|
|
515
|
+
try { pendingPermissions[k]({ behavior: "deny", message: "Worker shutting down" }); } catch(e) {}
|
|
516
|
+
}
|
|
517
|
+
for (var k in pendingMcpCalls) {
|
|
518
|
+
try { pendingMcpCalls[k].reject(new Error("Worker shutting down")); } catch(e) {}
|
|
519
|
+
}
|
|
520
|
+
for (var k in pendingAskUser) {
|
|
521
|
+
try { pendingAskUser[k](new Error("Worker shutting down")); } catch(e) {}
|
|
522
|
+
}
|
|
523
|
+
for (var k in pendingElicitations) {
|
|
524
|
+
try { pendingElicitations[k](new Error("Worker shutting down")); } catch(e) {}
|
|
525
|
+
}
|
|
495
526
|
queryInstance = null;
|
|
496
527
|
messageQueue = null;
|
|
497
528
|
abortController = null;
|
|
498
529
|
pendingPermissions = {};
|
|
499
530
|
pendingAskUser = {};
|
|
500
531
|
pendingElicitations = {};
|
|
532
|
+
pendingMcpCalls = {};
|
|
501
533
|
}
|
|
502
534
|
}
|
|
503
535
|
|
package/lib/server-admin.js
CHANGED
|
@@ -1,6 +1,8 @@
|
|
|
1
1
|
// Admin API endpoints (multi-user mode only)
|
|
2
2
|
// Extracted from server.js
|
|
3
3
|
|
|
4
|
+
var audit = require("./audit");
|
|
5
|
+
|
|
4
6
|
function attachAdmin(ctx) {
|
|
5
7
|
var users = ctx.users;
|
|
6
8
|
var smtp = ctx.smtp;
|
|
@@ -84,6 +86,12 @@ function attachAdmin(ctx) {
|
|
|
84
86
|
if (onUserDeleted && targetLinuxUser) {
|
|
85
87
|
onUserDeleted(targetUserId, targetLinuxUser);
|
|
86
88
|
}
|
|
89
|
+
audit.log("user.delete", {
|
|
90
|
+
actorId: mu.id,
|
|
91
|
+
actorName: mu.username,
|
|
92
|
+
target: targetUserId,
|
|
93
|
+
metadata: targetUser ? { username: targetUser.username, role: targetUser.role } : null,
|
|
94
|
+
});
|
|
87
95
|
res.writeHead(200, { "Content-Type": "application/json" });
|
|
88
96
|
res.end('{"ok":true}');
|
|
89
97
|
return true;
|
|
@@ -131,6 +139,12 @@ function attachAdmin(ctx) {
|
|
|
131
139
|
if (onUserProvisioned) onUserProvisioned(result.user.id, provision.linuxUser);
|
|
132
140
|
}
|
|
133
141
|
}
|
|
142
|
+
audit.log("user.create", {
|
|
143
|
+
actorId: mu.id,
|
|
144
|
+
actorName: mu.username,
|
|
145
|
+
target: result.user.id,
|
|
146
|
+
metadata: { username: result.user.username, role: result.user.role },
|
|
147
|
+
});
|
|
134
148
|
res.writeHead(200, { "Content-Type": "application/json" });
|
|
135
149
|
res.end(JSON.stringify({
|
|
136
150
|
ok: true,
|
|
@@ -187,6 +201,12 @@ function attachAdmin(ctx) {
|
|
|
187
201
|
break;
|
|
188
202
|
}
|
|
189
203
|
}
|
|
204
|
+
audit.log("user.pin.reset", {
|
|
205
|
+
actorId: mu.id,
|
|
206
|
+
actorName: mu.username,
|
|
207
|
+
target: targetUserId,
|
|
208
|
+
metadata: { username: targetUser.username },
|
|
209
|
+
});
|
|
190
210
|
res.writeHead(200, { "Content-Type": "application/json" });
|
|
191
211
|
res.end(JSON.stringify({ ok: true, tempPin: newPin }));
|
|
192
212
|
return true;
|
|
@@ -421,6 +441,11 @@ function attachAdmin(ctx) {
|
|
|
421
441
|
// Allow clearing SMTP config by sending empty fields
|
|
422
442
|
if (!data.host && !data.user && !data.pass && !data.from) {
|
|
423
443
|
smtp.saveSmtpConfig(null);
|
|
444
|
+
audit.log("settings.smtp.update", {
|
|
445
|
+
actorId: mu.id,
|
|
446
|
+
actorName: mu.username,
|
|
447
|
+
metadata: { cleared: true },
|
|
448
|
+
});
|
|
424
449
|
res.writeHead(200, { "Content-Type": "application/json" });
|
|
425
450
|
res.end('{"ok":true}');
|
|
426
451
|
return;
|
|
@@ -445,6 +470,12 @@ function attachAdmin(ctx) {
|
|
|
445
470
|
from: data.from,
|
|
446
471
|
emailLoginEnabled: !!data.emailLoginEnabled,
|
|
447
472
|
});
|
|
473
|
+
audit.log("settings.smtp.update", {
|
|
474
|
+
actorId: mu.id,
|
|
475
|
+
actorName: mu.username,
|
|
476
|
+
// Log field names only — never log host credentials, passwords, or secrets.
|
|
477
|
+
metadata: { fieldsUpdated: ["host", "port", "secure", "user", "from", "emailLoginEnabled"] },
|
|
478
|
+
});
|
|
448
479
|
res.writeHead(200, { "Content-Type": "application/json" });
|
|
449
480
|
res.end('{"ok":true}');
|
|
450
481
|
} catch (e) {
|
|
@@ -701,6 +732,44 @@ function attachAdmin(ctx) {
|
|
|
701
732
|
return true;
|
|
702
733
|
}
|
|
703
734
|
|
|
735
|
+
// GET /api/admin/audit — tail the audit log (admin only, read-only)
|
|
736
|
+
if (req.method === "GET" && fullUrl.indexOf("/api/admin/audit") === 0) {
|
|
737
|
+
if (!users.isMultiUser()) {
|
|
738
|
+
res.writeHead(404, { "Content-Type": "application/json" });
|
|
739
|
+
res.end('{"error":"Not found"}');
|
|
740
|
+
return true;
|
|
741
|
+
}
|
|
742
|
+
var mu = getMultiUserFromReq(req);
|
|
743
|
+
if (!mu || mu.role !== "admin") {
|
|
744
|
+
res.writeHead(403, { "Content-Type": "application/json" });
|
|
745
|
+
res.end('{"error":"Admin access required"}');
|
|
746
|
+
return true;
|
|
747
|
+
}
|
|
748
|
+
var auditPath = require("path").join(require("./config").CONFIG_DIR, "audit.log");
|
|
749
|
+
var fs = require("fs");
|
|
750
|
+
try {
|
|
751
|
+
var raw = fs.readFileSync(auditPath, "utf8");
|
|
752
|
+
var allLines = raw.split("\n").filter(function (l) { return l.trim().length > 0; });
|
|
753
|
+
var N = 200;
|
|
754
|
+
var tail = allLines.slice(-N);
|
|
755
|
+
var entries = [];
|
|
756
|
+
for (var li = 0; li < tail.length; li++) {
|
|
757
|
+
try { entries.push(JSON.parse(tail[li])); } catch (_) {}
|
|
758
|
+
}
|
|
759
|
+
res.writeHead(200, { "Content-Type": "application/json" });
|
|
760
|
+
res.end(JSON.stringify({ entries: entries, total_lines: allLines.length }));
|
|
761
|
+
} catch (e) {
|
|
762
|
+
if (e.code === "ENOENT") {
|
|
763
|
+
res.writeHead(200, { "Content-Type": "application/json" });
|
|
764
|
+
res.end('{"entries":[],"total_lines":0}');
|
|
765
|
+
} else {
|
|
766
|
+
res.writeHead(500, { "Content-Type": "application/json" });
|
|
767
|
+
res.end(JSON.stringify({ error: "Failed to read audit log" }));
|
|
768
|
+
}
|
|
769
|
+
}
|
|
770
|
+
return true;
|
|
771
|
+
}
|
|
772
|
+
|
|
704
773
|
return false;
|
|
705
774
|
}
|
|
706
775
|
|
package/lib/server-auth.js
CHANGED
|
@@ -3,6 +3,12 @@ var fs = require("fs");
|
|
|
3
3
|
var path = require("path");
|
|
4
4
|
var { CONFIG_DIR } = require("./config");
|
|
5
5
|
var _isDevMode = require("./config").isDevMode;
|
|
6
|
+
var store = require("./store");
|
|
7
|
+
var audit = require("./audit");
|
|
8
|
+
|
|
9
|
+
// Default token TTL: 30 days. Tokens issued before expiry support was added are
|
|
10
|
+
// treated as valid for one additional TTL cycle to avoid forced logouts on upgrade.
|
|
11
|
+
var TOKEN_TTL_MS = 30 * 24 * 60 * 60 * 1000;
|
|
6
12
|
|
|
7
13
|
// --- PIN hashing ---
|
|
8
14
|
|
|
@@ -64,16 +70,34 @@ function attachAuth(ctx) {
|
|
|
64
70
|
var authToken = ctx.pinHash || null;
|
|
65
71
|
|
|
66
72
|
// --- Multi-user auth tokens (persisted to disk) ---
|
|
67
|
-
var
|
|
73
|
+
var TOKENS_NAME = _isDevMode ? "auth-tokens-dev.json" : "auth-tokens.json";
|
|
68
74
|
var MULTI_USER_COOKIE = _isDevMode ? "relay_auth_user_dev" : "relay_auth_user";
|
|
69
75
|
var multiUserTokens = {};
|
|
70
76
|
|
|
71
77
|
function loadTokens() {
|
|
78
|
+
// Synchronous at startup: read directly so the server is ready before accepting
|
|
79
|
+
// connections. store.js is used for all subsequent writes.
|
|
72
80
|
try {
|
|
73
|
-
var raw = fs.readFileSync(
|
|
81
|
+
var raw = fs.readFileSync(path.join(CONFIG_DIR, TOKENS_NAME), "utf8");
|
|
74
82
|
var data = JSON.parse(raw);
|
|
75
83
|
if (data && typeof data === "object") {
|
|
84
|
+
// Migration: tokens stored as plain userId strings (legacy format) or as
|
|
85
|
+
// objects with {userId, issuedAt, expiresAt}. Upgrade legacy entries in
|
|
86
|
+
// place so they are valid for one TTL cycle, then require the field.
|
|
87
|
+
var now = Date.now();
|
|
88
|
+
var migrated = false;
|
|
89
|
+
for (var tok in data) {
|
|
90
|
+
var entry = data[tok];
|
|
91
|
+
if (typeof entry === "string") {
|
|
92
|
+
data[tok] = { userId: entry, issuedAt: now, expiresAt: now + TOKEN_TTL_MS };
|
|
93
|
+
migrated = true;
|
|
94
|
+
} else if (entry && typeof entry === "object" && !entry.expiresAt) {
|
|
95
|
+
entry.expiresAt = (entry.issuedAt || now) + TOKEN_TTL_MS;
|
|
96
|
+
migrated = true;
|
|
97
|
+
}
|
|
98
|
+
}
|
|
76
99
|
multiUserTokens = data;
|
|
100
|
+
if (migrated) saveTokens();
|
|
77
101
|
}
|
|
78
102
|
} catch (e) {
|
|
79
103
|
multiUserTokens = {};
|
|
@@ -81,19 +105,18 @@ function attachAuth(ctx) {
|
|
|
81
105
|
}
|
|
82
106
|
|
|
83
107
|
function saveTokens() {
|
|
84
|
-
|
|
85
|
-
|
|
86
|
-
|
|
87
|
-
|
|
88
|
-
fs.renameSync(tmpPath, TOKENS_FILE);
|
|
89
|
-
} catch (e) {}
|
|
108
|
+
// Async atomic write through store.js (queued per file, 0o600).
|
|
109
|
+
store.writeJson(TOKENS_NAME, multiUserTokens).catch(function (err) {
|
|
110
|
+
process.stderr.write("[server-auth] saveTokens failed: " + (err && err.message ? err.message : err) + "\n");
|
|
111
|
+
});
|
|
90
112
|
}
|
|
91
113
|
|
|
92
114
|
loadTokens();
|
|
93
115
|
|
|
94
116
|
function createMultiUserSession(userId) {
|
|
95
117
|
var token = users.generateUserAuthToken(userId);
|
|
96
|
-
|
|
118
|
+
var now = Date.now();
|
|
119
|
+
multiUserTokens[token] = { userId: userId, issuedAt: now, expiresAt: now + TOKEN_TTL_MS };
|
|
97
120
|
saveTokens();
|
|
98
121
|
var cookie = MULTI_USER_COOKIE + "=" + token + "; Path=/; HttpOnly; SameSite=Lax; Max-Age=31536000" + (tlsOptions ? "; Secure" : "");
|
|
99
122
|
return { token: token, cookie: cookie };
|
|
@@ -103,8 +126,16 @@ function attachAuth(ctx) {
|
|
|
103
126
|
var cookies = parseCookies(req);
|
|
104
127
|
var token = cookies[MULTI_USER_COOKIE];
|
|
105
128
|
if (!token) return null;
|
|
106
|
-
var
|
|
129
|
+
var entry = multiUserTokens[token];
|
|
130
|
+
if (!entry) return null;
|
|
131
|
+
var userId = typeof entry === "object" ? entry.userId : entry;
|
|
107
132
|
if (!userId) return null;
|
|
133
|
+
// Reject expired tokens
|
|
134
|
+
if (entry.expiresAt && Date.now() > entry.expiresAt) {
|
|
135
|
+
delete multiUserTokens[token];
|
|
136
|
+
saveTokens();
|
|
137
|
+
return null;
|
|
138
|
+
}
|
|
108
139
|
var user = users.findUserById(userId);
|
|
109
140
|
return user || null;
|
|
110
141
|
}
|
|
@@ -116,17 +147,48 @@ function attachAuth(ctx) {
|
|
|
116
147
|
function revokeUserTokens(userId) {
|
|
117
148
|
var changed = false;
|
|
118
149
|
for (var token in multiUserTokens) {
|
|
119
|
-
|
|
150
|
+
var entry = multiUserTokens[token];
|
|
151
|
+
var entryUserId = typeof entry === "object" ? entry.userId : entry;
|
|
152
|
+
if (entryUserId === userId) {
|
|
120
153
|
delete multiUserTokens[token];
|
|
121
154
|
changed = true;
|
|
122
155
|
}
|
|
123
156
|
}
|
|
124
|
-
if (changed)
|
|
157
|
+
if (changed) {
|
|
158
|
+
saveTokens();
|
|
159
|
+
audit.log("auth.token.revoke_all", {
|
|
160
|
+
actorId: "system",
|
|
161
|
+
target: userId,
|
|
162
|
+
});
|
|
163
|
+
}
|
|
125
164
|
}
|
|
126
165
|
|
|
127
166
|
// --- PIN rate limiting (per-instance state) ---
|
|
128
167
|
var pinAttempts = {};
|
|
129
168
|
|
|
169
|
+
// Per-username failure tracking with progressive backoff.
|
|
170
|
+
// Backoff thresholds (cumulative failures): 1s, 5s, 30s, 5min, permanent lockout.
|
|
171
|
+
var PIN_USER_BACKOFF_MS = [1000, 5000, 30000, 5 * 60 * 1000];
|
|
172
|
+
var PIN_USER_PERMANENT_THRESHOLD = PIN_USER_BACKOFF_MS.length + 1;
|
|
173
|
+
var pinAttemptsUser = {};
|
|
174
|
+
var lockedUsers = new Set();
|
|
175
|
+
|
|
176
|
+
function isUserLockedOut(username) {
|
|
177
|
+
return lockedUsers.has(username);
|
|
178
|
+
}
|
|
179
|
+
|
|
180
|
+
function unlockUser(username) {
|
|
181
|
+
lockedUsers.delete(username);
|
|
182
|
+
delete pinAttemptsUser[username];
|
|
183
|
+
}
|
|
184
|
+
|
|
185
|
+
function getUserBackoffMs(username) {
|
|
186
|
+
var entry = pinAttemptsUser[username];
|
|
187
|
+
if (!entry) return 0;
|
|
188
|
+
var idx = Math.min(entry.count - 1, PIN_USER_BACKOFF_MS.length - 1);
|
|
189
|
+
return idx >= 0 ? PIN_USER_BACKOFF_MS[idx] : 0;
|
|
190
|
+
}
|
|
191
|
+
|
|
130
192
|
function checkPinRateLimit(ip) {
|
|
131
193
|
var entry = pinAttempts[ip];
|
|
132
194
|
if (!entry) return null;
|
|
@@ -140,16 +202,54 @@ function attachAuth(ctx) {
|
|
|
140
202
|
return null;
|
|
141
203
|
}
|
|
142
204
|
|
|
205
|
+
// Check both IP and username lockouts. Returns seconds to wait, or null if clear.
|
|
206
|
+
function checkPinRateLimitWithUser(ip, username) {
|
|
207
|
+
var ipResult = checkPinRateLimit(ip);
|
|
208
|
+
if (ipResult !== null) return ipResult;
|
|
209
|
+
if (username && isUserLockedOut(username)) {
|
|
210
|
+
// Permanent lockout — signal with a large sentinel value (admin must unlock)
|
|
211
|
+
return -1;
|
|
212
|
+
}
|
|
213
|
+
if (username) {
|
|
214
|
+
var entry = pinAttemptsUser[username];
|
|
215
|
+
if (entry && entry.count > 0) {
|
|
216
|
+
var backoff = getUserBackoffMs(username);
|
|
217
|
+
if (backoff > 0) {
|
|
218
|
+
var elapsed = Date.now() - entry.lastAttempt;
|
|
219
|
+
if (elapsed < backoff) return Math.ceil((backoff - elapsed) / 1000);
|
|
220
|
+
}
|
|
221
|
+
}
|
|
222
|
+
}
|
|
223
|
+
return null;
|
|
224
|
+
}
|
|
225
|
+
|
|
143
226
|
function recordPinFailure(ip) {
|
|
144
227
|
if (!pinAttempts[ip]) pinAttempts[ip] = { count: 0, lastAttempt: 0 };
|
|
145
228
|
pinAttempts[ip].count++;
|
|
146
229
|
pinAttempts[ip].lastAttempt = Date.now();
|
|
147
230
|
}
|
|
148
231
|
|
|
232
|
+
function recordPinFailureWithUser(ip, username) {
|
|
233
|
+
recordPinFailure(ip);
|
|
234
|
+
if (username) {
|
|
235
|
+
if (!pinAttemptsUser[username]) pinAttemptsUser[username] = { count: 0, lastAttempt: 0 };
|
|
236
|
+
pinAttemptsUser[username].count++;
|
|
237
|
+
pinAttemptsUser[username].lastAttempt = Date.now();
|
|
238
|
+
if (pinAttemptsUser[username].count >= PIN_USER_PERMANENT_THRESHOLD) {
|
|
239
|
+
lockedUsers.add(username);
|
|
240
|
+
}
|
|
241
|
+
}
|
|
242
|
+
}
|
|
243
|
+
|
|
149
244
|
function clearPinFailures(ip) {
|
|
150
245
|
delete pinAttempts[ip];
|
|
151
246
|
}
|
|
152
247
|
|
|
248
|
+
function clearPinFailuresWithUser(ip, username) {
|
|
249
|
+
clearPinFailures(ip);
|
|
250
|
+
if (username) delete pinAttemptsUser[username];
|
|
251
|
+
}
|
|
252
|
+
|
|
153
253
|
// --- Admin password recovery (in-memory, one-time) ---
|
|
154
254
|
var recovery = null;
|
|
155
255
|
|
|
@@ -452,8 +552,12 @@ function attachAuth(ctx) {
|
|
|
452
552
|
return true;
|
|
453
553
|
}
|
|
454
554
|
var ip = req.socket.remoteAddress || "";
|
|
555
|
+
// IP-only pre-check (username not yet known — body not read)
|
|
455
556
|
var remaining = checkPinRateLimit(ip);
|
|
456
557
|
if (remaining !== null) {
|
|
558
|
+
audit.log("auth.lockout", {
|
|
559
|
+
metadata: { ip: ip, retryAfterSeconds: remaining },
|
|
560
|
+
});
|
|
457
561
|
res.writeHead(429, { "Content-Type": "application/json" });
|
|
458
562
|
res.end(JSON.stringify({ ok: false, locked: true, retryAfter: remaining }));
|
|
459
563
|
return true;
|
|
@@ -463,15 +567,23 @@ function attachAuth(ctx) {
|
|
|
463
567
|
req.on("end", function () {
|
|
464
568
|
try {
|
|
465
569
|
var data = JSON.parse(body);
|
|
466
|
-
var
|
|
570
|
+
var username = data.username || null;
|
|
571
|
+
// Per-username lockout check (after body is available)
|
|
572
|
+
var userRemaining = checkPinRateLimitWithUser(ip, username);
|
|
573
|
+
if (userRemaining !== null) {
|
|
574
|
+
res.writeHead(429, { "Content-Type": "application/json" });
|
|
575
|
+
res.end(JSON.stringify({ ok: false, locked: true, retryAfter: userRemaining }));
|
|
576
|
+
return;
|
|
577
|
+
}
|
|
578
|
+
var user = users.authenticateUser(username, data.pin);
|
|
467
579
|
if (!user) {
|
|
468
|
-
|
|
580
|
+
recordPinFailureWithUser(ip, username);
|
|
469
581
|
var attemptsLeft = PIN_MAX_ATTEMPTS - (pinAttempts[ip] ? pinAttempts[ip].count : 0);
|
|
470
582
|
res.writeHead(401, { "Content-Type": "application/json" });
|
|
471
583
|
res.end(JSON.stringify({ ok: false, error: "Invalid username or PIN", attemptsLeft: Math.max(attemptsLeft, 0) }));
|
|
472
584
|
return;
|
|
473
585
|
}
|
|
474
|
-
|
|
586
|
+
clearPinFailuresWithUser(ip, user.username);
|
|
475
587
|
var session = createMultiUserSession(user.id);
|
|
476
588
|
var loginResp = { ok: true, user: { id: user.id, username: user.username, role: user.role } };
|
|
477
589
|
if (user.mustChangePin) loginResp.mustChangePin = true;
|
|
@@ -731,6 +843,8 @@ function attachAuth(ctx) {
|
|
|
731
843
|
setAuthToken: setAuthToken,
|
|
732
844
|
getAuthPage: getAuthPage,
|
|
733
845
|
createMultiUserSession: createMultiUserSession,
|
|
846
|
+
isUserLockedOut: isUserLockedOut,
|
|
847
|
+
unlockUser: unlockUser,
|
|
734
848
|
};
|
|
735
849
|
}
|
|
736
850
|
|
package/lib/server-settings.js
CHANGED
|
@@ -1,5 +1,6 @@
|
|
|
1
1
|
var fs = require("fs");
|
|
2
2
|
var path = require("path");
|
|
3
|
+
var audit = require("./audit");
|
|
3
4
|
|
|
4
5
|
function attachSettings(ctx) {
|
|
5
6
|
var users = ctx.users;
|
|
@@ -540,6 +541,10 @@ function attachSettings(ctx) {
|
|
|
540
541
|
res.end(JSON.stringify({ error: result.error }));
|
|
541
542
|
return true;
|
|
542
543
|
}
|
|
544
|
+
audit.log("settings.multiuser.enable", {
|
|
545
|
+
actorId: "system",
|
|
546
|
+
metadata: null,
|
|
547
|
+
});
|
|
543
548
|
res.writeHead(200, { "Content-Type": "application/json" });
|
|
544
549
|
res.end(JSON.stringify({ ok: true, setupCode: result.setupCode }));
|
|
545
550
|
return true;
|
package/lib/server.js
CHANGED
|
@@ -269,6 +269,7 @@ function createServer(opts) {
|
|
|
269
269
|
broadcastAll: function (msg) { broadcastAll(msg); },
|
|
270
270
|
sendToUser: function (userId, msg) { sendToUser(userId, msg); },
|
|
271
271
|
pushModule: pushModule,
|
|
272
|
+
isMultiUser: function () { return users.isMultiUser(); },
|
|
272
273
|
});
|
|
273
274
|
|
|
274
275
|
// --- External trigger watcher (global singleton) ---
|