@neuralnomads/codenomad 0.17.0 → 0.19.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/README.md +12 -0
- package/THIRD_PARTY_NOTICES.md +26 -0
- package/dist/auth/manager.js +1 -1
- package/dist/background-processes/manager.js +15 -30
- package/dist/background-processes/manager.test.js +123 -0
- package/dist/config/schema.js +2 -1
- package/dist/config/schema.test.js +13 -0
- package/dist/events/bus.js +17 -0
- package/dist/events/bus.test.js +37 -0
- package/dist/filesystem/__tests__/search-cache.test.js +20 -8
- package/dist/filesystem/__tests__/search.test.js +53 -0
- package/dist/filesystem/search-cache.js +6 -10
- package/dist/filesystem/search.js +22 -9
- package/dist/index.js +77 -58
- package/dist/index.test.js +62 -0
- package/dist/opencode-plugin/codenomad-opencode-plugin.tgz +0 -0
- package/dist/opencode-update/service.js +150 -0
- package/dist/opencode-update/service.test.js +107 -0
- package/dist/permissions/auto-accept-manager.js +380 -0
- package/dist/permissions/auto-accept-manager.test.js +736 -0
- package/dist/permissions/auto-accept-store.js +118 -0
- package/dist/permissions/auto-accept-store.test.js +157 -0
- package/dist/permissions/opencode-replier.js +31 -0
- package/dist/permissions/opencode-yolo-metadata.js +81 -0
- package/dist/permissions/opencode-yolo-metadata.test.js +54 -0
- package/dist/server/__tests__/listener-retry.test.js +15 -0
- package/dist/server/__tests__/remote-proxy.test.js +151 -47
- package/dist/server/http-server.js +22 -9
- package/dist/server/remote-proxy.js +91 -34
- package/dist/server/routes/auth-pages/login.html +3 -3
- package/dist/server/routes/auth.js +1 -1
- package/dist/server/routes/auth.test.js +21 -0
- package/dist/server/routes/opencode-update.js +37 -0
- package/dist/server/routes/opencode-update.test.js +34 -0
- package/dist/server/routes/remote-servers.js +1 -1
- package/dist/server/routes/settings.js +48 -2
- package/dist/server/routes/settings.test.js +58 -0
- package/dist/server/routes/usage.js +18 -0
- package/dist/server/routes/usage.test.js +26 -0
- package/dist/server/routes/workspaces.js +34 -2
- package/dist/server/routes/workspaces.test.js +113 -0
- package/dist/server/routes/worktrees.js +19 -0
- package/dist/server/routes/yolo.js +13 -0
- package/dist/server/tls.js +2 -2
- package/dist/settings/binaries.js +4 -1
- package/dist/settings/binaries.test.js +19 -0
- package/dist/settings/public-config.js +14 -0
- package/dist/settings/public-config.test.js +56 -0
- package/dist/settings/service.js +17 -5
- package/dist/settings/service.test.js +51 -0
- package/dist/settings/yaml-doc-store.js +55 -4
- package/dist/settings/yaml-doc-store.test.js +78 -0
- package/dist/shutdown.js +83 -0
- package/dist/shutdown.test.js +148 -0
- package/dist/sidecars/manager.js +26 -3
- package/dist/sidecars/manager.test.js +42 -0
- package/dist/speech/service.js +121 -10
- package/dist/speech/service.test.js +247 -0
- package/dist/ui/remote-ui.js +2 -2
- package/dist/usage/providers/api-key.js +171 -0
- package/dist/usage/providers/google.js +171 -0
- package/dist/usage/providers/minimax.js +109 -0
- package/dist/usage/providers/oauth.js +76 -0
- package/dist/usage/providers/special.js +148 -0
- package/dist/usage/service.js +83 -0
- package/dist/usage/service.test.js +61 -0
- package/dist/usage/shared.js +130 -0
- package/dist/usage/shared.test.js +33 -0
- package/dist/usage/types.js +1 -0
- package/dist/workspaces/__tests__/spawn.test.js +64 -7
- package/dist/workspaces/__tests__/workspace-identity.test.js +163 -0
- package/dist/workspaces/binary-path.test.js +10 -0
- package/dist/workspaces/instance-client.js +42 -0
- package/dist/workspaces/instance-client.test.js +149 -0
- package/dist/workspaces/instance-events.js +2 -2
- package/dist/workspaces/launch-cleanup.test.js +29 -0
- package/dist/workspaces/loopback.js +8 -0
- package/dist/workspaces/manager.js +473 -128
- package/dist/workspaces/manager.test.js +335 -0
- package/dist/workspaces/process-identity.darwin.test.js +88 -0
- package/dist/workspaces/process-identity.js +449 -0
- package/dist/workspaces/process-identity.test.js +140 -0
- package/dist/workspaces/runtime.js +471 -138
- package/dist/workspaces/runtime.test.js +286 -0
- package/dist/workspaces/spawn.js +86 -15
- package/dist/workspaces/workspace-identity.js +27 -0
- package/package.json +2 -1
- package/public/assets/FilesTab-Cbs7b7y9.js +2 -0
- package/public/assets/{GitChangesTab-BksCi53d.js → GitChangesTab-D3H4cqJJ.js} +2 -2
- package/public/assets/{SplitFilePanel-CrSfR22r.js → SplitFilePanel-C_Bcle0r.js} +1 -1
- package/public/assets/StatusTab-D1-tfkgN.js +1 -0
- package/public/assets/{align-justify-hRtBz8xe.js → align-justify-B5HUL_LR.js} +1 -1
- package/public/assets/{bundle-full-BVDA-a9Y.js → bundle-full-CEFzES5w.js} +1 -1
- package/public/assets/{diff-viewer-BCAI0Cw8.js → diff-viewer-BBC2_yI1.js} +1 -1
- package/public/assets/{git-diff-vendor-CSgooKT_.js → git-diff-vendor-CYS3ApzA.js} +1 -1
- package/public/assets/{index-DnCBfFB3.js → index-B81f0aWL.js} +1 -1
- package/public/assets/index-BHlYVddm.js +1 -0
- package/public/assets/index-Best16ZB.js +2 -0
- package/public/assets/index-Boq37ErX.js +1 -0
- package/public/assets/index-By9pgzQk.css +1 -0
- package/public/assets/index-C0caoeJg.js +1 -0
- package/public/assets/index-Dqg2UVvS.js +1 -0
- package/public/assets/index-it6EGJV6.js +1 -0
- package/public/assets/{index-Ddsv8Uc0.js → index-lORR8OnW.js} +1 -1
- package/public/assets/index-ppe6yWaU.js +1 -0
- package/public/assets/index-wEqeBwqT.js +1 -0
- package/public/assets/index-yEcajWX_.js +1 -0
- package/public/assets/{loading-bD3ppK2l.js → loading-CbUWFqQ_.js} +1 -1
- package/public/assets/main-DfSREDgt.js +69 -0
- package/public/assets/{markdown-DJuaMC5H.js → markdown-CEtfpKK-.js} +60 -47
- package/public/assets/monaco-viewer-NKl8kwH2.js +26 -0
- package/public/assets/terminal-square-q-by1uT7.js +1 -0
- package/public/assets/tool-call-CZL2uqIM.js +59 -0
- package/public/assets/unified-picker-CvJXD-j8.js +1 -0
- package/public/assets/{wrap-text-BkcW_eTA.js → wrap-text-Bo7xr74P.js} +1 -1
- package/public/index.html +5 -5
- package/public/loading.html +5 -5
- package/public/sw.js +1 -1
- package/public/ui-version.json +1 -1
- package/public/assets/FilesTab-B5ysoRLh.js +0 -2
- package/public/assets/StatusTab-Dgqekgjn.js +0 -1
- package/public/assets/index-B2Qd6xQq.css +0 -1
- package/public/assets/index-BQpEhdk5.js +0 -1
- package/public/assets/index-BXIEm2zT.js +0 -1
- package/public/assets/index-CWjU9mAF.js +0 -1
- package/public/assets/index-Cvtlo58a.js +0 -1
- package/public/assets/index-DFlxnvHT.js +0 -2
- package/public/assets/index-Dn7woJnK.js +0 -1
- package/public/assets/index-DnXT1F8T.js +0 -1
- package/public/assets/index-Kv-3BRTi.js +0 -1
- package/public/assets/index-g-G1RiME.js +0 -1
- package/public/assets/main-BsbMOeQg.js +0 -65
- package/public/assets/monaco-viewer-BFNhPQX7.js +0 -26
- package/public/assets/tool-call-BSJluZRW.js +0 -59
- package/public/assets/unified-picker-DmFyrIis.js +0 -1
|
@@ -0,0 +1,51 @@
|
|
|
1
|
+
import assert from "node:assert/strict";
|
|
2
|
+
import { describe, it } from "node:test";
|
|
3
|
+
import { SettingsService } from "./service";
|
|
4
|
+
function serviceWithStore(store) {
|
|
5
|
+
const service = Object.create(SettingsService.prototype);
|
|
6
|
+
Object.assign(service, { configStore: store, eventBus: undefined });
|
|
7
|
+
return service;
|
|
8
|
+
}
|
|
9
|
+
describe("SettingsService config persistence", () => {
|
|
10
|
+
it("normalizes and persists a document patch once", () => {
|
|
11
|
+
let writes = 0;
|
|
12
|
+
const service = serviceWithStore({
|
|
13
|
+
get: () => ({ server: { logLevel: "info" } }),
|
|
14
|
+
replace: (value) => {
|
|
15
|
+
writes += 1;
|
|
16
|
+
return value;
|
|
17
|
+
},
|
|
18
|
+
mergePatch: () => assert.fail("must not persist an intermediate document"),
|
|
19
|
+
});
|
|
20
|
+
const result = service.mergePatchDoc("config", { ui: { theme: "dark" } });
|
|
21
|
+
assert.equal(writes, 1);
|
|
22
|
+
assert.deepEqual(result, { server: { logLevel: "INFO" }, ui: { theme: "dark" } });
|
|
23
|
+
});
|
|
24
|
+
it("normalizes and persists a server-owner patch once", () => {
|
|
25
|
+
let writes = 0;
|
|
26
|
+
const service = serviceWithStore({
|
|
27
|
+
getOwner: () => ({ logLevel: "info", sidecars: [] }),
|
|
28
|
+
replaceOwner: (_owner, value) => {
|
|
29
|
+
writes += 1;
|
|
30
|
+
return value;
|
|
31
|
+
},
|
|
32
|
+
mergePatchOwner: () => assert.fail("must not persist an intermediate owner"),
|
|
33
|
+
});
|
|
34
|
+
const result = service.mergePatchOwner("config", "server", { sidecars: [{ id: "one" }] });
|
|
35
|
+
assert.equal(writes, 1);
|
|
36
|
+
assert.deepEqual(result, { logLevel: "INFO", sidecars: [{ id: "one" }] });
|
|
37
|
+
});
|
|
38
|
+
it("does not report a persisted patch as failed when an event listener throws", () => {
|
|
39
|
+
let warnings = 0;
|
|
40
|
+
const service = serviceWithStore({
|
|
41
|
+
getOwner: () => ({}),
|
|
42
|
+
mergePatchOwner: (_owner, patch) => patch,
|
|
43
|
+
});
|
|
44
|
+
Object.assign(service, {
|
|
45
|
+
eventBus: { publish: () => { throw new Error("listener failed"); } },
|
|
46
|
+
logger: { warn: () => { warnings += 1; } },
|
|
47
|
+
});
|
|
48
|
+
assert.deepEqual(service.mergePatchOwner("config", "ui", { theme: "dark" }), { theme: "dark" });
|
|
49
|
+
assert.equal(warnings, 1);
|
|
50
|
+
});
|
|
51
|
+
});
|
|
@@ -1,5 +1,6 @@
|
|
|
1
1
|
import fs from "fs";
|
|
2
2
|
import path from "path";
|
|
3
|
+
import { randomUUID } from "node:crypto";
|
|
3
4
|
import { parse as parseYaml, stringify as stringifyYaml } from "yaml";
|
|
4
5
|
import { applyMergePatch, isPlainObject } from "./merge-patch";
|
|
5
6
|
function ensureTrailingNewline(content) {
|
|
@@ -13,10 +14,32 @@ function normalizeDoc(input) {
|
|
|
13
14
|
}
|
|
14
15
|
return input;
|
|
15
16
|
}
|
|
17
|
+
function resolveWriteDestination(filePath) {
|
|
18
|
+
let current = path.resolve(filePath);
|
|
19
|
+
const seen = new Set();
|
|
20
|
+
while (true) {
|
|
21
|
+
let stat;
|
|
22
|
+
try {
|
|
23
|
+
stat = fs.lstatSync(current);
|
|
24
|
+
}
|
|
25
|
+
catch (error) {
|
|
26
|
+
if (error?.code === "ENOENT")
|
|
27
|
+
return current;
|
|
28
|
+
throw error;
|
|
29
|
+
}
|
|
30
|
+
if (!stat.isSymbolicLink())
|
|
31
|
+
return current;
|
|
32
|
+
if (seen.has(current))
|
|
33
|
+
throw new Error(`Circular settings symlink: ${filePath}`);
|
|
34
|
+
seen.add(current);
|
|
35
|
+
current = path.resolve(path.dirname(current), fs.readlinkSync(current));
|
|
36
|
+
}
|
|
37
|
+
}
|
|
16
38
|
export class YamlDocStore {
|
|
17
|
-
constructor(filePath, logger) {
|
|
39
|
+
constructor(filePath, logger, options = {}) {
|
|
18
40
|
this.filePath = filePath;
|
|
19
41
|
this.logger = logger;
|
|
42
|
+
this.options = options;
|
|
20
43
|
this.cache = {};
|
|
21
44
|
this.loaded = false;
|
|
22
45
|
}
|
|
@@ -48,9 +71,18 @@ export class YamlDocStore {
|
|
|
48
71
|
}
|
|
49
72
|
replace(next) {
|
|
50
73
|
const normalized = normalizeDoc(next);
|
|
74
|
+
const previousCache = this.cache;
|
|
75
|
+
const previousLoaded = this.loaded;
|
|
51
76
|
this.cache = normalized;
|
|
52
77
|
this.loaded = true;
|
|
53
|
-
|
|
78
|
+
try {
|
|
79
|
+
this.persist();
|
|
80
|
+
}
|
|
81
|
+
catch (error) {
|
|
82
|
+
this.cache = previousCache;
|
|
83
|
+
this.loaded = previousLoaded;
|
|
84
|
+
throw error;
|
|
85
|
+
}
|
|
54
86
|
return this.cache;
|
|
55
87
|
}
|
|
56
88
|
mergePatch(patch) {
|
|
@@ -84,13 +116,32 @@ export class YamlDocStore {
|
|
|
84
116
|
return nextOwner;
|
|
85
117
|
}
|
|
86
118
|
persist() {
|
|
119
|
+
let tempPath;
|
|
87
120
|
try {
|
|
88
|
-
|
|
121
|
+
const destination = resolveWriteDestination(this.filePath);
|
|
122
|
+
fs.mkdirSync(path.dirname(destination), { recursive: true });
|
|
89
123
|
const yaml = stringifyYaml(this.cache);
|
|
90
|
-
fs.
|
|
124
|
+
const mode = fs.existsSync(destination) ? fs.statSync(destination).mode & 0o777 : 0o600;
|
|
125
|
+
tempPath = `${destination}.${process.pid}.${randomUUID()}.tmp`;
|
|
126
|
+
fs.writeFileSync(tempPath, ensureTrailingNewline(yaml), { encoding: "utf-8", mode });
|
|
127
|
+
if (process.platform !== "win32")
|
|
128
|
+
fs.chmodSync(tempPath, mode);
|
|
129
|
+
fs.renameSync(tempPath, destination);
|
|
91
130
|
}
|
|
92
131
|
catch (error) {
|
|
93
132
|
this.logger.warn({ err: error, filePath: this.filePath }, "Failed to persist YAML doc");
|
|
133
|
+
if (this.options.throwOnPersistError)
|
|
134
|
+
throw error;
|
|
135
|
+
}
|
|
136
|
+
finally {
|
|
137
|
+
if (tempPath) {
|
|
138
|
+
try {
|
|
139
|
+
fs.rmSync(tempPath, { force: true });
|
|
140
|
+
}
|
|
141
|
+
catch (error) {
|
|
142
|
+
this.logger.warn({ err: error, tempPath }, "Failed to remove temporary YAML doc");
|
|
143
|
+
}
|
|
144
|
+
}
|
|
94
145
|
}
|
|
95
146
|
}
|
|
96
147
|
}
|
|
@@ -0,0 +1,78 @@
|
|
|
1
|
+
import assert from "node:assert/strict";
|
|
2
|
+
import fs from "node:fs";
|
|
3
|
+
import os from "node:os";
|
|
4
|
+
import path from "node:path";
|
|
5
|
+
import { describe, it } from "node:test";
|
|
6
|
+
import { YamlDocStore } from "./yaml-doc-store";
|
|
7
|
+
describe("YamlDocStore", () => {
|
|
8
|
+
it("reports persistence failures without replacing the cached document", () => {
|
|
9
|
+
const root = fs.mkdtempSync(path.join(os.tmpdir(), "codenomad-yaml-store-"));
|
|
10
|
+
const parent = path.join(root, "settings");
|
|
11
|
+
const file = path.join(parent, "config.yaml");
|
|
12
|
+
const store = new YamlDocStore(file, { warn() { } }, { throwOnPersistError: true });
|
|
13
|
+
try {
|
|
14
|
+
store.replace({ version: 1 });
|
|
15
|
+
fs.rmSync(parent, { recursive: true });
|
|
16
|
+
fs.writeFileSync(parent, "blocks directory creation");
|
|
17
|
+
assert.throws(() => store.replace({ version: 2 }));
|
|
18
|
+
assert.deepEqual(store.get(), { version: 1 });
|
|
19
|
+
}
|
|
20
|
+
finally {
|
|
21
|
+
fs.rmSync(root, { recursive: true, force: true });
|
|
22
|
+
}
|
|
23
|
+
});
|
|
24
|
+
it("keeps the live document intact when atomic replacement fails", () => {
|
|
25
|
+
const root = fs.mkdtempSync(path.join(os.tmpdir(), "codenomad-yaml-store-"));
|
|
26
|
+
const file = path.join(root, "config.yaml");
|
|
27
|
+
const store = new YamlDocStore(file, { warn() { } }, { throwOnPersistError: true });
|
|
28
|
+
const renameSync = fs.renameSync;
|
|
29
|
+
try {
|
|
30
|
+
store.replace({ version: 1 });
|
|
31
|
+
fs.renameSync = () => { throw new Error("replacement failed"); };
|
|
32
|
+
assert.throws(() => store.replace({ version: 2 }));
|
|
33
|
+
assert.match(fs.readFileSync(file, "utf8"), /version: 1/);
|
|
34
|
+
assert.deepEqual(store.get(), { version: 1 });
|
|
35
|
+
fs.renameSync = renameSync;
|
|
36
|
+
store.replace({ version: 2 });
|
|
37
|
+
assert.match(fs.readFileSync(file, "utf8"), /version: 2/);
|
|
38
|
+
}
|
|
39
|
+
finally {
|
|
40
|
+
;
|
|
41
|
+
fs.renameSync = renameSync;
|
|
42
|
+
fs.rmSync(root, { recursive: true, force: true });
|
|
43
|
+
}
|
|
44
|
+
});
|
|
45
|
+
it("preserves private file permissions", { skip: process.platform === "win32" }, () => {
|
|
46
|
+
const root = fs.mkdtempSync(path.join(os.tmpdir(), "codenomad-yaml-store-"));
|
|
47
|
+
const file = path.join(root, "config.yaml");
|
|
48
|
+
const store = new YamlDocStore(file, { warn() { } }, { throwOnPersistError: true });
|
|
49
|
+
try {
|
|
50
|
+
store.replace({ version: 1 });
|
|
51
|
+
fs.chmodSync(file, 0o664);
|
|
52
|
+
store.replace({ version: 2 });
|
|
53
|
+
assert.equal(fs.statSync(file).mode & 0o777, 0o664);
|
|
54
|
+
}
|
|
55
|
+
finally {
|
|
56
|
+
fs.rmSync(root, { recursive: true, force: true });
|
|
57
|
+
}
|
|
58
|
+
});
|
|
59
|
+
it("updates the final target without replacing a symlink chain", { skip: process.platform === "win32" }, () => {
|
|
60
|
+
const root = fs.mkdtempSync(path.join(os.tmpdir(), "codenomad-yaml-store-"));
|
|
61
|
+
const target = path.join(root, "target.yaml");
|
|
62
|
+
const intermediate = path.join(root, "current.yaml");
|
|
63
|
+
const link = path.join(root, "config.yaml");
|
|
64
|
+
fs.writeFileSync(target, "version: 1\n");
|
|
65
|
+
fs.symlinkSync(target, intermediate);
|
|
66
|
+
fs.symlinkSync(intermediate, link);
|
|
67
|
+
const store = new YamlDocStore(link, { warn() { } }, { throwOnPersistError: true });
|
|
68
|
+
try {
|
|
69
|
+
store.replace({ version: 2 });
|
|
70
|
+
assert.equal(fs.lstatSync(link).isSymbolicLink(), true);
|
|
71
|
+
assert.equal(fs.lstatSync(intermediate).isSymbolicLink(), true);
|
|
72
|
+
assert.match(fs.readFileSync(target, "utf8"), /version: 2/);
|
|
73
|
+
}
|
|
74
|
+
finally {
|
|
75
|
+
fs.rmSync(root, { recursive: true, force: true });
|
|
76
|
+
}
|
|
77
|
+
});
|
|
78
|
+
});
|
package/dist/shutdown.js
ADDED
|
@@ -0,0 +1,83 @@
|
|
|
1
|
+
export const SERVER_SHUTDOWN_COMPLETE = "CODENOMAD_SHUTDOWN_STATUS:complete";
|
|
2
|
+
export const SERVER_SHUTDOWN_INCOMPLETE = "CODENOMAD_SHUTDOWN_STATUS:incomplete";
|
|
3
|
+
export function createServerShutdownHandler(options) {
|
|
4
|
+
const forceExit = options.forceExit ?? process.exit;
|
|
5
|
+
const setExitCode = options.setExitCode ?? ((code) => { process.exitCode = code; });
|
|
6
|
+
const reportStatus = options.reportStatus ?? ((status) => console.log(status));
|
|
7
|
+
let pending;
|
|
8
|
+
return (signal) => {
|
|
9
|
+
if (pending) {
|
|
10
|
+
options.logger.error({ signal }, "Additional shutdown signal received; forcing nonzero exit");
|
|
11
|
+
forceExit(1);
|
|
12
|
+
return pending;
|
|
13
|
+
}
|
|
14
|
+
options.logger.info({ signal }, "Received shutdown signal, stopping workspaces and server");
|
|
15
|
+
pending = Promise.resolve().then(options.shutdown).then(() => {
|
|
16
|
+
options.logger.info({}, "Shutdown complete");
|
|
17
|
+
reportStatus(SERVER_SHUTDOWN_COMPLETE);
|
|
18
|
+
setExitCode(0);
|
|
19
|
+
}, async (error) => {
|
|
20
|
+
options.logger.error({ err: error }, "Server shutdown incomplete; retrying cleanup");
|
|
21
|
+
const retryAttempts = Math.max(0, Math.floor(options.retryAttempts ?? 3));
|
|
22
|
+
for (let attempt = 1; attempt <= retryAttempts; attempt += 1) {
|
|
23
|
+
await new Promise((resolve) => setTimeout(resolve, options.retryDelayMs ?? 250));
|
|
24
|
+
try {
|
|
25
|
+
await options.shutdown();
|
|
26
|
+
options.logger.info({}, "Shutdown cleanup retry completed");
|
|
27
|
+
reportStatus(SERVER_SHUTDOWN_COMPLETE);
|
|
28
|
+
setExitCode(0);
|
|
29
|
+
return;
|
|
30
|
+
}
|
|
31
|
+
catch (retryError) {
|
|
32
|
+
options.logger.warn({ err: retryError, attempt, attempts: retryAttempts }, "Shutdown cleanup retry remains incomplete");
|
|
33
|
+
}
|
|
34
|
+
}
|
|
35
|
+
options.logger.error({ attempts: retryAttempts }, "Shutdown cleanup retries exhausted; preserving process-tree containment");
|
|
36
|
+
reportStatus(SERVER_SHUTDOWN_INCOMPLETE);
|
|
37
|
+
setExitCode(1);
|
|
38
|
+
if (options.holdAfterFailure)
|
|
39
|
+
await options.holdAfterFailure();
|
|
40
|
+
});
|
|
41
|
+
return pending;
|
|
42
|
+
};
|
|
43
|
+
}
|
|
44
|
+
export async function orchestrateServerShutdown(operations, logger, workspaceAttempts = 2) {
|
|
45
|
+
const errors = [];
|
|
46
|
+
const namedError = (name, cause) => Object.assign(new Error(`${name} failed: ${cause instanceof Error ? cause.message : String(cause)}`), { cause });
|
|
47
|
+
const settle = async (pending) => {
|
|
48
|
+
const results = await Promise.allSettled(pending.map(([, run]) => Promise.resolve().then(run)));
|
|
49
|
+
for (let index = 0; index < results.length; index += 1) {
|
|
50
|
+
const result = results[index];
|
|
51
|
+
if (result.status !== "rejected")
|
|
52
|
+
continue;
|
|
53
|
+
const error = namedError(pending[index][0], result.reason);
|
|
54
|
+
errors.push(error);
|
|
55
|
+
logger.error({ err: error }, "Server resource shutdown failed");
|
|
56
|
+
}
|
|
57
|
+
};
|
|
58
|
+
const workspaceShutdown = (async () => {
|
|
59
|
+
const attempts = Math.max(1, Math.floor(workspaceAttempts));
|
|
60
|
+
for (let attempt = 1; attempt <= attempts; attempt += 1) {
|
|
61
|
+
const [result] = await Promise.allSettled([Promise.resolve().then(operations.stopWorkspaces)]);
|
|
62
|
+
if (result.status === "fulfilled")
|
|
63
|
+
break;
|
|
64
|
+
if (attempt < attempts) {
|
|
65
|
+
logger.warn({ err: result.reason, attempt, attempts }, "Workspace manager shutdown failed; retrying cleanup");
|
|
66
|
+
continue;
|
|
67
|
+
}
|
|
68
|
+
const error = namedError("stopWorkspaces", result.reason);
|
|
69
|
+
errors.push(error);
|
|
70
|
+
logger.error({ err: error, attempts }, "Workspace manager shutdown failed");
|
|
71
|
+
}
|
|
72
|
+
})();
|
|
73
|
+
await Promise.all([
|
|
74
|
+
settle([
|
|
75
|
+
["stopInstanceEventBridge", operations.stopInstanceEventBridge], ["stopSidecars", operations.stopSidecars],
|
|
76
|
+
["stopClientConnections", operations.stopClientConnections], ["stopRemoteProxySessions", operations.stopRemoteProxySessions],
|
|
77
|
+
]),
|
|
78
|
+
workspaceShutdown,
|
|
79
|
+
]);
|
|
80
|
+
await settle([["stopHttpServers", operations.stopHttpServers], ["stopReleaseMonitor", operations.stopReleaseMonitor]]);
|
|
81
|
+
if (errors.length)
|
|
82
|
+
throw new AggregateError(errors, "Server shutdown failed");
|
|
83
|
+
}
|
|
@@ -0,0 +1,148 @@
|
|
|
1
|
+
import assert from "node:assert/strict";
|
|
2
|
+
import { describe, it } from "node:test";
|
|
3
|
+
import { createServerShutdownHandler, orchestrateServerShutdown, SERVER_SHUTDOWN_COMPLETE, SERVER_SHUTDOWN_INCOMPLETE, } from "./shutdown";
|
|
4
|
+
const logger = { info() { }, warn() { }, error() { } };
|
|
5
|
+
const operations = (overrides = {}) => ({
|
|
6
|
+
stopInstanceEventBridge() { }, stopSidecars() { }, stopClientConnections() { },
|
|
7
|
+
stopRemoteProxySessions() { }, stopWorkspaces() { }, stopHttpServers() { }, stopReleaseMonitor() { },
|
|
8
|
+
...overrides,
|
|
9
|
+
});
|
|
10
|
+
describe("server shutdown orchestration", () => {
|
|
11
|
+
it("retries workspace cleanup and preserves shutdown order", async () => {
|
|
12
|
+
const calls = [];
|
|
13
|
+
let attempts = 0;
|
|
14
|
+
await orchestrateServerShutdown(operations({
|
|
15
|
+
stopRemoteProxySessions: () => { calls.push("remote-proxy"); },
|
|
16
|
+
stopWorkspaces: () => { calls.push(`workspaces-${++attempts}`); if (attempts === 1)
|
|
17
|
+
throw new Error("still alive"); },
|
|
18
|
+
stopHttpServers: () => { calls.push("http"); },
|
|
19
|
+
}), logger);
|
|
20
|
+
assert.deepEqual(calls, ["workspaces-1", "remote-proxy", "workspaces-2", "http"]);
|
|
21
|
+
});
|
|
22
|
+
it("closes remaining resources and aggregates the concrete current error", async () => {
|
|
23
|
+
const failure = new Error("workspace abc POSIX process group is still alive");
|
|
24
|
+
const closed = [];
|
|
25
|
+
let attempts = 0;
|
|
26
|
+
await assert.rejects(orchestrateServerShutdown(operations({
|
|
27
|
+
stopWorkspaces: () => { attempts++; throw failure; },
|
|
28
|
+
stopHttpServers: () => { closed.push("http"); },
|
|
29
|
+
stopReleaseMonitor: () => { closed.push("release-monitor"); },
|
|
30
|
+
}), logger), (error) => {
|
|
31
|
+
assert.ok(error instanceof AggregateError);
|
|
32
|
+
assert.equal(error.errors.length, 1);
|
|
33
|
+
assert.match(error.errors[0].message, /^stopWorkspaces failed:/);
|
|
34
|
+
assert.strictEqual(error.errors[0].cause, failure);
|
|
35
|
+
return true;
|
|
36
|
+
});
|
|
37
|
+
assert.deepEqual([attempts, closed], [2, ["http", "release-monitor"]]);
|
|
38
|
+
});
|
|
39
|
+
it("starts workspace cleanup without waiting for preliminary shutdown", async () => {
|
|
40
|
+
let releasePreliminary;
|
|
41
|
+
const preliminary = new Promise((resolve) => { releasePreliminary = resolve; });
|
|
42
|
+
let workspaceStarted = false;
|
|
43
|
+
const shutdown = orchestrateServerShutdown(operations({
|
|
44
|
+
stopRemoteProxySessions: () => preliminary,
|
|
45
|
+
stopWorkspaces: () => { workspaceStarted = true; },
|
|
46
|
+
}), logger);
|
|
47
|
+
await new Promise((resolve) => setImmediate(resolve));
|
|
48
|
+
assert.equal(workspaceStarted, true);
|
|
49
|
+
releasePreliminary();
|
|
50
|
+
await shutdown;
|
|
51
|
+
});
|
|
52
|
+
});
|
|
53
|
+
describe("server shutdown signal boundary", () => {
|
|
54
|
+
it("reports incomplete cleanup and holds for final tree enforcement", async () => {
|
|
55
|
+
const calls = [];
|
|
56
|
+
const exits = [];
|
|
57
|
+
const statuses = [];
|
|
58
|
+
let releaseHold;
|
|
59
|
+
const hold = new Promise((resolve) => { releaseHold = resolve; });
|
|
60
|
+
const handler = createServerShutdownHandler({
|
|
61
|
+
shutdown: async () => { calls.push("cleanup"); throw new Error("retained child survived"); },
|
|
62
|
+
logger: { info: () => calls.push("info"), warn() { }, error: () => calls.push("error") },
|
|
63
|
+
forceExit: (code) => { calls.push("force-exit"); exits.push(code); },
|
|
64
|
+
setExitCode: () => undefined,
|
|
65
|
+
reportStatus: (status) => statuses.push(status),
|
|
66
|
+
holdAfterFailure: () => hold,
|
|
67
|
+
retryAttempts: 0,
|
|
68
|
+
});
|
|
69
|
+
const pending = handler("SIGTERM");
|
|
70
|
+
await new Promise((resolve) => setImmediate(resolve));
|
|
71
|
+
assert.deepEqual([exits, statuses, calls], [[], [SERVER_SHUTDOWN_INCOMPLETE], ["info", "cleanup", "error", "error"]]);
|
|
72
|
+
handler("SIGTERM");
|
|
73
|
+
assert.deepEqual(exits, [1]);
|
|
74
|
+
releaseHold();
|
|
75
|
+
await pending;
|
|
76
|
+
});
|
|
77
|
+
it("reports complete cleanup before allowing natural exit", async () => {
|
|
78
|
+
const statuses = [], exitCodes = [];
|
|
79
|
+
const handler = createServerShutdownHandler({
|
|
80
|
+
shutdown: async () => undefined,
|
|
81
|
+
logger,
|
|
82
|
+
reportStatus: (status) => statuses.push(status),
|
|
83
|
+
setExitCode: (code) => exitCodes.push(code),
|
|
84
|
+
});
|
|
85
|
+
await handler("stdin");
|
|
86
|
+
assert.deepEqual(statuses, [SERVER_SHUTDOWN_COMPLETE]);
|
|
87
|
+
assert.deepEqual(exitCodes, [0]);
|
|
88
|
+
});
|
|
89
|
+
it("keeps retrying identity-aware cleanup during the final enforcement budget", async () => {
|
|
90
|
+
let attempts = 0;
|
|
91
|
+
const statuses = [], exitCodes = [];
|
|
92
|
+
const handler = createServerShutdownHandler({
|
|
93
|
+
shutdown: async () => {
|
|
94
|
+
attempts++;
|
|
95
|
+
if (attempts === 1)
|
|
96
|
+
throw new Error("detached group still alive");
|
|
97
|
+
},
|
|
98
|
+
logger,
|
|
99
|
+
reportStatus: (status) => statuses.push(status),
|
|
100
|
+
setExitCode: (code) => exitCodes.push(code),
|
|
101
|
+
retryDelayMs: 0,
|
|
102
|
+
});
|
|
103
|
+
await handler("stdin");
|
|
104
|
+
assert.equal(attempts, 2);
|
|
105
|
+
assert.deepEqual(statuses, [SERVER_SHUTDOWN_COMPLETE]);
|
|
106
|
+
assert.deepEqual(exitCodes, [0]);
|
|
107
|
+
});
|
|
108
|
+
it("preserves containment after the standalone cleanup retry budget", async () => {
|
|
109
|
+
let attempts = 0;
|
|
110
|
+
const statuses = [], exitCodes = [], forcedExits = [];
|
|
111
|
+
let releaseHold;
|
|
112
|
+
const hold = new Promise((resolve) => { releaseHold = resolve; });
|
|
113
|
+
const handler = createServerShutdownHandler({
|
|
114
|
+
shutdown: async () => { attempts++; throw new Error("process tree remains alive"); },
|
|
115
|
+
logger,
|
|
116
|
+
reportStatus: (status) => statuses.push(status),
|
|
117
|
+
setExitCode: (code) => exitCodes.push(code),
|
|
118
|
+
forceExit: (code) => forcedExits.push(code),
|
|
119
|
+
holdAfterFailure: () => hold,
|
|
120
|
+
retryDelayMs: 0,
|
|
121
|
+
retryAttempts: 2,
|
|
122
|
+
});
|
|
123
|
+
const pending = handler("stdin");
|
|
124
|
+
while (attempts < 3)
|
|
125
|
+
await new Promise((resolve) => setTimeout(resolve, 0));
|
|
126
|
+
assert.equal(attempts, 3);
|
|
127
|
+
assert.deepEqual(statuses, [SERVER_SHUTDOWN_INCOMPLETE]);
|
|
128
|
+
assert.deepEqual(exitCodes, [1]);
|
|
129
|
+
assert.deepEqual(forcedExits, []);
|
|
130
|
+
handler("SIGTERM");
|
|
131
|
+
assert.deepEqual(forcedExits, [1]);
|
|
132
|
+
releaseHold();
|
|
133
|
+
await pending;
|
|
134
|
+
});
|
|
135
|
+
it("escalates a second signal while sharing first-signal cleanup", async () => {
|
|
136
|
+
let finish;
|
|
137
|
+
const cleanup = new Promise((resolve) => { finish = resolve; });
|
|
138
|
+
const exits = [], exitCodes = [];
|
|
139
|
+
const handler = createServerShutdownHandler({ shutdown: () => cleanup, logger,
|
|
140
|
+
forceExit: (code) => exits.push(code), setExitCode: (code) => exitCodes.push(code), reportStatus: () => undefined });
|
|
141
|
+
const first = handler("SIGINT"), second = handler("SIGTERM");
|
|
142
|
+
assert.strictEqual(first, second);
|
|
143
|
+
assert.deepEqual(exits, [1]);
|
|
144
|
+
finish();
|
|
145
|
+
await first;
|
|
146
|
+
assert.deepEqual(exitCodes, [0]);
|
|
147
|
+
});
|
|
148
|
+
});
|
package/dist/sidecars/manager.js
CHANGED
|
@@ -45,18 +45,32 @@ export class SideCarManager {
|
|
|
45
45
|
};
|
|
46
46
|
this.configs.set(record.id, record);
|
|
47
47
|
this.runtime.set(record.id, { status: "stopped" });
|
|
48
|
-
|
|
48
|
+
try {
|
|
49
|
+
this.persistConfigs();
|
|
50
|
+
}
|
|
51
|
+
catch (error) {
|
|
52
|
+
this.configs.delete(record.id);
|
|
53
|
+
this.runtime.delete(record.id);
|
|
54
|
+
throw error;
|
|
55
|
+
}
|
|
49
56
|
await this.refreshPortSideCar(record.id);
|
|
50
57
|
return this.toSideCar(record);
|
|
51
58
|
}
|
|
52
59
|
async update(id, input) {
|
|
53
60
|
const record = this.requireConfig(id);
|
|
61
|
+
const previous = { ...record };
|
|
54
62
|
record.name = typeof input.name === "string" ? input.name.trim() : record.name;
|
|
55
63
|
record.port = typeof input.port === "number" ? input.port : record.port;
|
|
56
64
|
record.insecure = typeof input.insecure === "boolean" ? input.insecure : record.insecure;
|
|
57
65
|
record.prefixMode = typeof input.prefixMode === "string" ? input.prefixMode : record.prefixMode;
|
|
58
66
|
record.updatedAt = new Date().toISOString();
|
|
59
|
-
|
|
67
|
+
try {
|
|
68
|
+
this.persistConfigs();
|
|
69
|
+
}
|
|
70
|
+
catch (error) {
|
|
71
|
+
this.configs.set(id, previous);
|
|
72
|
+
throw error;
|
|
73
|
+
}
|
|
60
74
|
await this.refreshPortSideCar(id);
|
|
61
75
|
return this.toSideCar(record);
|
|
62
76
|
}
|
|
@@ -64,9 +78,18 @@ export class SideCarManager {
|
|
|
64
78
|
const record = this.configs.get(id);
|
|
65
79
|
if (!record)
|
|
66
80
|
return false;
|
|
81
|
+
const runtime = this.runtime.get(id);
|
|
67
82
|
this.configs.delete(id);
|
|
68
83
|
this.runtime.delete(id);
|
|
69
|
-
|
|
84
|
+
try {
|
|
85
|
+
this.persistConfigs();
|
|
86
|
+
}
|
|
87
|
+
catch (error) {
|
|
88
|
+
this.configs.set(id, record);
|
|
89
|
+
if (runtime)
|
|
90
|
+
this.runtime.set(id, runtime);
|
|
91
|
+
throw error;
|
|
92
|
+
}
|
|
70
93
|
this.options.eventBus.publish({ type: "sidecar.removed", sidecarId: id });
|
|
71
94
|
return true;
|
|
72
95
|
}
|
|
@@ -0,0 +1,42 @@
|
|
|
1
|
+
import assert from "node:assert/strict";
|
|
2
|
+
import { describe, it } from "node:test";
|
|
3
|
+
import { SideCarManager } from "./manager";
|
|
4
|
+
const existing = {
|
|
5
|
+
id: "existing",
|
|
6
|
+
kind: "port",
|
|
7
|
+
name: "Existing",
|
|
8
|
+
port: 65534,
|
|
9
|
+
insecure: true,
|
|
10
|
+
prefixMode: "strip",
|
|
11
|
+
createdAt: "2026-01-01T00:00:00.000Z",
|
|
12
|
+
updatedAt: "2026-01-01T00:00:00.000Z",
|
|
13
|
+
};
|
|
14
|
+
function manager(sidecars = []) {
|
|
15
|
+
return new SideCarManager({
|
|
16
|
+
settings: {
|
|
17
|
+
getOwner: () => ({ sidecars }),
|
|
18
|
+
mergePatchOwner: () => { throw new Error("disk full"); },
|
|
19
|
+
},
|
|
20
|
+
eventBus: { publish() { } },
|
|
21
|
+
logger: { warn() { } },
|
|
22
|
+
});
|
|
23
|
+
}
|
|
24
|
+
describe("SideCarManager persistence rollback", () => {
|
|
25
|
+
it("restores create, update, and delete state when persistence fails", async () => {
|
|
26
|
+
const createManager = manager();
|
|
27
|
+
await assert.rejects(createManager.create({
|
|
28
|
+
kind: "port",
|
|
29
|
+
name: "New",
|
|
30
|
+
port: 65533,
|
|
31
|
+
insecure: true,
|
|
32
|
+
prefixMode: "strip",
|
|
33
|
+
}));
|
|
34
|
+
assert.deepEqual(await createManager.list(), []);
|
|
35
|
+
const updateManager = manager([existing]);
|
|
36
|
+
await assert.rejects(updateManager.update(existing.id, { name: "Changed" }));
|
|
37
|
+
assert.equal((await updateManager.get(existing.id))?.name, existing.name);
|
|
38
|
+
const deleteManager = manager([existing]);
|
|
39
|
+
await assert.rejects(deleteManager.delete(existing.id));
|
|
40
|
+
assert.equal((await deleteManager.get(existing.id))?.id, existing.id);
|
|
41
|
+
});
|
|
42
|
+
});
|