@ai-ecoverse/slicc-agent 7.31.0 → 7.32.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 +14 -4
- package/dist/agent.js +4 -0
- package/dist/agent.js.map +2 -2
- package/dist/approvals/policy.js +27 -5
- package/dist/approvals/policy.js.map +2 -2
- package/dist/approvals/published.js +18 -0
- package/dist/approvals/published.js.map +7 -0
- package/dist/approvals/record.js +4 -1
- package/dist/approvals/record.js.map +2 -2
- package/dist/approvals/run-licks.js +137 -0
- package/dist/approvals/run-licks.js.map +7 -0
- package/dist/approvals/run-procs.js +127 -0
- package/dist/approvals/run-procs.js.map +7 -0
- package/dist/approvals/run.js +468 -0
- package/dist/approvals/run.js.map +7 -0
- package/dist/approvals/runnable.js +125 -0
- package/dist/approvals/runnable.js.map +7 -0
- package/dist/approvals/sudo.js +29 -1
- package/dist/approvals/sudo.js.map +2 -2
- package/dist/client.js +1 -0
- package/dist/client.js.map +2 -2
- package/dist/control.js +7 -1
- package/dist/control.js.map +2 -2
- package/dist/host.js +69 -16
- package/dist/host.js.map +2 -2
- package/dist/index.js +14 -0
- package/dist/index.js.map +2 -2
- package/dist/licks/extension.js +1 -0
- package/dist/licks/extension.js.map +2 -2
- package/dist/licks/lick.js +1 -0
- package/dist/licks/lick.js.map +2 -2
- package/dist/main.js +1 -0
- package/dist/main.js.map +2 -2
- package/dist/services.js +7 -2
- package/dist/services.js.map +2 -2
- package/dist/spectrum/approvals-port.js +69 -0
- package/dist/spectrum/approvals-port.js.map +2 -2
- package/dist/spectrum/messages.js +2 -1
- package/dist/spectrum/messages.js.map +2 -2
- package/dist/spectrum/monitor-port.js +2 -1
- package/dist/spectrum/monitor-port.js.map +2 -2
- package/dist/types/agent.d.ts +2 -0
- package/dist/types/approvals/policy.d.ts +10 -1
- package/dist/types/approvals/published.d.ts +3 -0
- package/dist/types/approvals/record.d.ts +44 -1
- package/dist/types/approvals/run-licks.d.ts +18 -0
- package/dist/types/approvals/run-procs.d.ts +40 -0
- package/dist/types/approvals/run.d.ts +60 -0
- package/dist/types/approvals/runnable.d.ts +55 -0
- package/dist/types/approvals/sudo.d.ts +3 -1
- package/dist/types/client.d.ts +2 -0
- package/dist/types/host.d.ts +10 -0
- package/dist/types/index.d.ts +4 -1
- package/dist/types/kernel/client.d.ts +35 -0
- package/dist/types/licks/lick.d.ts +1 -1
- package/dist/types/licks/triage.d.ts +1 -1
- package/dist/types/main.d.ts +2 -1
- package/dist/types/services.d.ts +7 -2
- package/dist/types/spectrum/approvals-port.d.ts +10 -2
- package/package.json +3 -3
|
@@ -0,0 +1,127 @@
|
|
|
1
|
+
import { tagsOf } from "../kernel/sightings.js";
|
|
2
|
+
const RUN_TAG = "sudo-run:";
|
|
3
|
+
const RUNS_DIR = ".slicc/sudo-runs";
|
|
4
|
+
const GRACE_MS = 1e3;
|
|
5
|
+
const runTag = (id) => `${RUN_TAG}${id}`;
|
|
6
|
+
async function passwdOf(kernel, user) {
|
|
7
|
+
const passwd = await kernel.fs.readText("/etc/passwd").catch(() => "");
|
|
8
|
+
return passwd.split("\n").find((entry) => entry.startsWith(`${user}:`))?.split(":");
|
|
9
|
+
}
|
|
10
|
+
async function homeOf(kernel, user) {
|
|
11
|
+
const home = (await passwdOf(kernel, user))?.[5];
|
|
12
|
+
if (home) return home.replace(/\/+$/, "") || "/";
|
|
13
|
+
return user === "root" ? "/root" : `/home/${user}`;
|
|
14
|
+
}
|
|
15
|
+
async function uidOf(kernel, user) {
|
|
16
|
+
const uid = Number((await passwdOf(kernel, user))?.[2] ?? (user === "root" ? 0 : NaN));
|
|
17
|
+
return Number.isInteger(uid) ? uid : void 0;
|
|
18
|
+
}
|
|
19
|
+
function aborted(signal) {
|
|
20
|
+
return new Promise((_, reject) => {
|
|
21
|
+
if (signal?.aborted) reject(signal.reason);
|
|
22
|
+
signal?.addEventListener("abort", () => reject(signal.reason), { once: true });
|
|
23
|
+
});
|
|
24
|
+
}
|
|
25
|
+
async function asUser(kernel, argv, user, signal) {
|
|
26
|
+
const made = await kernel.spawn(argv, { user, cwd: "/" });
|
|
27
|
+
return Promise.race([made.exited, aborted(signal)]);
|
|
28
|
+
}
|
|
29
|
+
async function outputOf(kernel, user, id, signal) {
|
|
30
|
+
const home = await homeOf(kernel, user);
|
|
31
|
+
const dir = `${home === "/" ? "" : home}/${RUNS_DIR}`;
|
|
32
|
+
const code = await asUser(kernel, ["mkdir", "-p", dir], user, signal);
|
|
33
|
+
if (code !== 0) throw new Error(`can't create ${dir} as ${user}`);
|
|
34
|
+
return { stdout: `${dir}/${id}.out`, stderr: `${dir}/${id}.err` };
|
|
35
|
+
}
|
|
36
|
+
async function removeOutput(kernel, user, paths) {
|
|
37
|
+
await asUser(kernel, ["rm", "-f", "--", ...paths], user).catch(() => void 0);
|
|
38
|
+
}
|
|
39
|
+
async function outputSize(kernel, paths) {
|
|
40
|
+
const sizes = await Promise.all(
|
|
41
|
+
paths.map(
|
|
42
|
+
(path) => kernel.fs.lstat(path).then((stat) => stat.isFile ? stat.size : 0).catch(() => 0)
|
|
43
|
+
)
|
|
44
|
+
);
|
|
45
|
+
return sizes.reduce((sum, size) => sum + size, 0);
|
|
46
|
+
}
|
|
47
|
+
async function watchExits(kernel, tag) {
|
|
48
|
+
const exits = /* @__PURE__ */ new Map();
|
|
49
|
+
const waiting = /* @__PURE__ */ new Map();
|
|
50
|
+
const subscription = await kernel.trace?.(tag, ({ events }) => {
|
|
51
|
+
for (const event of events) {
|
|
52
|
+
if (event.type !== "exit") continue;
|
|
53
|
+
const exit = { status: event.status, ...event.signal ? { signal: event.signal } : {} };
|
|
54
|
+
exits.set(event.pid, exit);
|
|
55
|
+
waiting.get(event.pid)?.(exit);
|
|
56
|
+
}
|
|
57
|
+
}).catch(() => void 0);
|
|
58
|
+
return {
|
|
59
|
+
waitFor: (pid) => new Promise((resolve) => {
|
|
60
|
+
const known = exits.get(pid);
|
|
61
|
+
if (known) resolve(known);
|
|
62
|
+
else waiting.set(pid, resolve);
|
|
63
|
+
}),
|
|
64
|
+
close: () => subscription?.close()
|
|
65
|
+
};
|
|
66
|
+
}
|
|
67
|
+
const sleep = (ms, signal) => new Promise((resolve, reject) => {
|
|
68
|
+
const abort = () => {
|
|
69
|
+
clearTimeout(timer);
|
|
70
|
+
reject(signal?.reason);
|
|
71
|
+
};
|
|
72
|
+
const timer = setTimeout(() => {
|
|
73
|
+
signal?.removeEventListener("abort", abort);
|
|
74
|
+
resolve();
|
|
75
|
+
}, ms);
|
|
76
|
+
if (signal?.aborted) abort();
|
|
77
|
+
else signal?.addEventListener("abort", abort, { once: true });
|
|
78
|
+
});
|
|
79
|
+
async function alive(kernel, pid) {
|
|
80
|
+
const rows = await kernel.ps?.().catch(() => void 0);
|
|
81
|
+
return !rows || rows.some((row) => row.pid === pid && row.state !== "Z");
|
|
82
|
+
}
|
|
83
|
+
async function gone(kernel, pid, ms, signal) {
|
|
84
|
+
while (await alive(kernel, pid)) await sleep(ms, signal);
|
|
85
|
+
await sleep(GRACE_MS, signal);
|
|
86
|
+
return {};
|
|
87
|
+
}
|
|
88
|
+
async function tagged(kernel, tag) {
|
|
89
|
+
const rows = await kernel.ps?.().catch(() => void 0);
|
|
90
|
+
if (!rows) return null;
|
|
91
|
+
return rows.filter((row) => row.state !== "Z" && tagsOf(row).includes(tag)).sort((a, b) => a.pid - b.pid);
|
|
92
|
+
}
|
|
93
|
+
async function signalTree(kernel, tag, killMs) {
|
|
94
|
+
const rows = await tagged(kernel, tag);
|
|
95
|
+
if (!rows) return "unknown";
|
|
96
|
+
if (!rows.length) return "none";
|
|
97
|
+
const send = (list, signal) => Promise.all(list.map((row) => kernel.kill?.(row.pid, signal).catch(() => void 0)));
|
|
98
|
+
await send(rows, "SIGTERM");
|
|
99
|
+
setTimeout(() => {
|
|
100
|
+
void tagged(kernel, tag).then((left) => left ? send(left, "SIGKILL") : void 0);
|
|
101
|
+
}, killMs);
|
|
102
|
+
return "sent";
|
|
103
|
+
}
|
|
104
|
+
async function adoptable(kernel, tag, target) {
|
|
105
|
+
const uid = await uidOf(kernel, target);
|
|
106
|
+
const rows = await tagged(kernel, tag) ?? [];
|
|
107
|
+
const mine = rows.filter((row) => uid !== void 0 && row.uid === uid);
|
|
108
|
+
return mine.find((row) => row.pid === row.pgid) ?? mine[0];
|
|
109
|
+
}
|
|
110
|
+
export {
|
|
111
|
+
GRACE_MS,
|
|
112
|
+
RUNS_DIR,
|
|
113
|
+
RUN_TAG,
|
|
114
|
+
aborted,
|
|
115
|
+
adoptable,
|
|
116
|
+
gone,
|
|
117
|
+
outputOf,
|
|
118
|
+
outputSize,
|
|
119
|
+
removeOutput,
|
|
120
|
+
runTag,
|
|
121
|
+
signalTree,
|
|
122
|
+
sleep,
|
|
123
|
+
tagged,
|
|
124
|
+
uidOf,
|
|
125
|
+
watchExits
|
|
126
|
+
};
|
|
127
|
+
//# sourceMappingURL=run-procs.js.map
|
|
@@ -0,0 +1,7 @@
|
|
|
1
|
+
{
|
|
2
|
+
"version": 3,
|
|
3
|
+
"sources": ["../../src/approvals/run-procs.ts"],
|
|
4
|
+
"sourcesContent": ["import type { KernelClient } from '../kernel/client.ts';\nimport { tagsOf } from '../kernel/sightings.ts';\n\nexport type RunKernel = Pick<KernelClient, 'fs' | 'spawn' | 'ps' | 'kill' | 'sudoRun' | 'trace'>;\n\nexport type Exit = { status?: number; signal?: string };\n\nexport const RUN_TAG = 'sudo-run:';\nexport const RUNS_DIR = '.slicc/sudo-runs';\nexport const GRACE_MS = 1000;\n\nexport const runTag = (id: string): string => `${RUN_TAG}${id}`;\n\ntype Row = NonNullable<Awaited<ReturnType<NonNullable<RunKernel['ps']>>>>[number];\n\nasync function passwdOf(kernel: RunKernel, user: string): Promise<string[] | undefined> {\n const passwd = await kernel.fs.readText('/etc/passwd').catch(() => '');\n return passwd\n .split('\\n')\n .find((entry) => entry.startsWith(`${user}:`))\n ?.split(':');\n}\n\nasync function homeOf(kernel: RunKernel, user: string): Promise<string> {\n const home = (await passwdOf(kernel, user))?.[5];\n if (home) return home.replace(/\\/+$/, '') || '/';\n return user === 'root' ? '/root' : `/home/${user}`;\n}\n\nexport async function uidOf(kernel: RunKernel, user: string): Promise<number | undefined> {\n const uid = Number((await passwdOf(kernel, user))?.[2] ?? (user === 'root' ? 0 : NaN));\n return Number.isInteger(uid) ? uid : undefined;\n}\n\nexport function aborted(signal: AbortSignal | undefined): Promise<never> {\n return new Promise((_, reject) => {\n if (signal?.aborted) reject(signal.reason);\n signal?.addEventListener('abort', () => reject(signal.reason), { once: true });\n });\n}\n\nasync function asUser(kernel: RunKernel, argv: string[], user: string, signal?: AbortSignal) {\n const made = await kernel.spawn(argv, { user, cwd: '/' });\n return Promise.race([made.exited, aborted(signal)]);\n}\n\nexport async function outputOf(kernel: RunKernel, user: string, id: string, signal?: AbortSignal) {\n const home = await homeOf(kernel, user);\n const dir = `${home === '/' ? '' : home}/${RUNS_DIR}`;\n const code = await asUser(kernel, ['mkdir', '-p', dir], user, signal);\n if (code !== 0) throw new Error(`can't create ${dir} as ${user}`);\n return { stdout: `${dir}/${id}.out`, stderr: `${dir}/${id}.err` };\n}\n\nexport async function removeOutput(kernel: RunKernel, user: string, paths: string[]) {\n await asUser(kernel, ['rm', '-f', '--', ...paths], user).catch(() => undefined);\n}\n\nexport async function outputSize(kernel: RunKernel, paths: string[]): Promise<number> {\n const sizes = await Promise.all(\n paths.map((path) =>\n kernel.fs\n .lstat(path)\n .then((stat) => (stat.isFile ? stat.size : 0))\n .catch(() => 0)\n )\n );\n return sizes.reduce((sum, size) => sum + size, 0);\n}\n\nexport type Watcher = { waitFor(pid: number): Promise<Exit>; close(): void };\n\nexport async function watchExits(kernel: RunKernel, tag: string): Promise<Watcher> {\n const exits = new Map<number, Exit>();\n const waiting = new Map<number, (exit: Exit) => void>();\n const subscription = await kernel\n .trace?.(tag, ({ events }) => {\n for (const event of events) {\n if (event.type !== 'exit') continue;\n const exit = { status: event.status, ...(event.signal ? { signal: event.signal } : {}) };\n exits.set(event.pid, exit);\n waiting.get(event.pid)?.(exit);\n }\n })\n .catch(() => undefined);\n return {\n waitFor: (pid) =>\n new Promise((resolve) => {\n const known = exits.get(pid);\n if (known) resolve(known);\n else waiting.set(pid, resolve);\n }),\n close: () => subscription?.close(),\n };\n}\n\nexport const sleep = (ms: number, signal?: AbortSignal) =>\n new Promise<void>((resolve, reject) => {\n const abort = () => {\n clearTimeout(timer);\n reject(signal?.reason);\n };\n const timer = setTimeout(() => {\n signal?.removeEventListener('abort', abort);\n resolve();\n }, ms);\n if (signal?.aborted) abort();\n else signal?.addEventListener('abort', abort, { once: true });\n });\n\nasync function alive(kernel: RunKernel, pid: number): Promise<boolean> {\n const rows = await kernel.ps?.().catch(() => undefined);\n return !rows || rows.some((row) => row.pid === pid && row.state !== 'Z');\n}\n\nexport async function gone(kernel: RunKernel, pid: number, ms: number, signal: AbortSignal) {\n while (await alive(kernel, pid)) await sleep(ms, signal);\n await sleep(GRACE_MS, signal);\n return {} as Exit;\n}\n\nexport async function tagged(kernel: RunKernel, tag: string): Promise<Row[] | null> {\n const rows = await kernel.ps?.().catch(() => undefined);\n if (!rows) return null;\n return rows\n .filter((row) => row.state !== 'Z' && tagsOf(row).includes(tag))\n .sort((a, b) => a.pid - b.pid);\n}\n\nexport type Signalled = 'sent' | 'none' | 'unknown';\n\nexport async function signalTree(\n kernel: RunKernel,\n tag: string,\n killMs: number\n): Promise<Signalled> {\n const rows = await tagged(kernel, tag);\n if (!rows) return 'unknown';\n if (!rows.length) return 'none';\n const send = (list: Row[], signal: string) =>\n Promise.all(list.map((row) => kernel.kill?.(row.pid, signal).catch(() => undefined)));\n await send(rows, 'SIGTERM');\n setTimeout(() => {\n void tagged(kernel, tag).then((left) => (left ? send(left, 'SIGKILL') : undefined));\n }, killMs);\n return 'sent';\n}\n\nexport async function adoptable(kernel: RunKernel, tag: string, target: string) {\n const uid = await uidOf(kernel, target);\n const rows = (await tagged(kernel, tag)) ?? [];\n const mine = rows.filter((row) => uid !== undefined && row.uid === uid);\n return mine.find((row) => row.pid === row.pgid) ?? mine[0];\n}\n"],
|
|
5
|
+
"mappings": "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",
|
|
6
|
+
"names": []
|
|
7
|
+
}
|
|
@@ -0,0 +1,468 @@
|
|
|
1
|
+
import { BACKGROUND_CONTEXT } from "@earendil-works/chord/context";
|
|
2
|
+
import {
|
|
3
|
+
defineExtension,
|
|
4
|
+
defineTask
|
|
5
|
+
} from "@earendil-works/pi-durable";
|
|
6
|
+
import {
|
|
7
|
+
ApprovalsDoc,
|
|
8
|
+
MAX_DELAY,
|
|
9
|
+
runLive
|
|
10
|
+
} from "./record.js";
|
|
11
|
+
import { endLick, KEEP_HOURS, MIB, startLick } from "./run-licks.js";
|
|
12
|
+
import {
|
|
13
|
+
aborted,
|
|
14
|
+
adoptable,
|
|
15
|
+
gone,
|
|
16
|
+
outputOf,
|
|
17
|
+
outputSize,
|
|
18
|
+
removeOutput,
|
|
19
|
+
runTag,
|
|
20
|
+
signalTree,
|
|
21
|
+
sleep,
|
|
22
|
+
tagged,
|
|
23
|
+
watchExits
|
|
24
|
+
} from "./run-procs.js";
|
|
25
|
+
import { RUN_REASONS, runnable } from "./runnable.js";
|
|
26
|
+
import { clock, duration, endLick as endLick2, startLick as startLick2 } from "./run-licks.js";
|
|
27
|
+
import { outputOf as outputOf2, RUN_TAG, RUNS_DIR, runTag as runTag2 } from "./run-procs.js";
|
|
28
|
+
const SUDO_RUN_TASK = "slicc.sudo-run";
|
|
29
|
+
const SUDO_RUNS = "slicc-sudo-runs";
|
|
30
|
+
const POLL_MS = 5e3;
|
|
31
|
+
const KILL_MS = 5e3;
|
|
32
|
+
const ADOPT_MS = 250;
|
|
33
|
+
const ADOPT_TRIES = 5;
|
|
34
|
+
const OUTPUT_CAP = 32 * MIB;
|
|
35
|
+
const KEEP_MS = KEEP_HOURS * 36e5;
|
|
36
|
+
const RUN_ERRORS = {
|
|
37
|
+
interrupted: "interrupted before it started",
|
|
38
|
+
reloaded: "the page reloaded while it ran",
|
|
39
|
+
idle: "This request isn't running.",
|
|
40
|
+
gone: "Its processes are already gone.",
|
|
41
|
+
unseen: "The kernel's process list isn't available, so it can't be stopped."
|
|
42
|
+
};
|
|
43
|
+
const DONE = { status: "terminal", outcome: { status: "completed", result: null } };
|
|
44
|
+
const next = (checkpoint) => ({ status: "running", checkpoint });
|
|
45
|
+
const sudoIn = (items, id) => {
|
|
46
|
+
const item = items?.find((entry) => entry.id === id);
|
|
47
|
+
return item?.kind === "sudo" ? item : void 0;
|
|
48
|
+
};
|
|
49
|
+
async function itemOf(runtime, id, context) {
|
|
50
|
+
return sudoIn((await runtime.snapshot(ApprovalsDoc, context))?.items, id);
|
|
51
|
+
}
|
|
52
|
+
async function claimed(runtime, id, context) {
|
|
53
|
+
const item = await itemOf(runtime, id, context);
|
|
54
|
+
if (item?.replay && item.run?.state === "starting") return item;
|
|
55
|
+
await runtime.commit(async () => DONE, context);
|
|
56
|
+
return void 0;
|
|
57
|
+
}
|
|
58
|
+
function edit(runtime, id, change, then, context) {
|
|
59
|
+
return runtime.commit(async (tx) => {
|
|
60
|
+
const item = sudoIn((await tx.doc(ApprovalsDoc)).items, id);
|
|
61
|
+
if (item?.run) change(item.run, item);
|
|
62
|
+
return then;
|
|
63
|
+
}, context);
|
|
64
|
+
}
|
|
65
|
+
const ended = (run, state, at, error) => {
|
|
66
|
+
run.state = state;
|
|
67
|
+
run.endedAt = at;
|
|
68
|
+
if (error) run.error = error;
|
|
69
|
+
};
|
|
70
|
+
function messageOf(error) {
|
|
71
|
+
if (error?.code === "ENOSYS") return RUN_REASONS.kernel;
|
|
72
|
+
const text = error instanceof Error ? error.message : String(error);
|
|
73
|
+
return text.trim() || "the kernel refused to run it";
|
|
74
|
+
}
|
|
75
|
+
async function tell(host, made) {
|
|
76
|
+
const event = await made.catch(() => void 0);
|
|
77
|
+
if (event) await host.licks?.deliver(event, BACKGROUND_CONTEXT).catch(() => void 0);
|
|
78
|
+
}
|
|
79
|
+
const stopTree = (host, id) => signalTree(host.kernel, runTag(id), host.killMs ?? KILL_MS);
|
|
80
|
+
const nowOf = (host) => host.now?.() ?? Date.now();
|
|
81
|
+
const knownBoots = (a, b) => a !== null && b !== null;
|
|
82
|
+
function memory() {
|
|
83
|
+
const calling = /* @__PURE__ */ new Set();
|
|
84
|
+
const ends = /* @__PURE__ */ new Map();
|
|
85
|
+
const watchers = /* @__PURE__ */ new Map();
|
|
86
|
+
return {
|
|
87
|
+
calling,
|
|
88
|
+
ends,
|
|
89
|
+
watcher(host, id) {
|
|
90
|
+
const found = watchers.get(id) ?? watchExits(host.kernel, runTag(id));
|
|
91
|
+
watchers.set(id, found);
|
|
92
|
+
return found;
|
|
93
|
+
},
|
|
94
|
+
async release(id) {
|
|
95
|
+
const found = watchers.get(id);
|
|
96
|
+
watchers.delete(id);
|
|
97
|
+
ends.delete(id);
|
|
98
|
+
calling.delete(id);
|
|
99
|
+
(await found)?.close();
|
|
100
|
+
}
|
|
101
|
+
};
|
|
102
|
+
}
|
|
103
|
+
function starting(lookup, mem) {
|
|
104
|
+
const { calling, ends, watcher, release } = mem;
|
|
105
|
+
const now = nowOf;
|
|
106
|
+
async function prepare(id, runtime, context) {
|
|
107
|
+
const host = await lookup();
|
|
108
|
+
const item = await claimed(runtime, id, context);
|
|
109
|
+
if (!item) return;
|
|
110
|
+
const place = await outputOf(host.kernel, item.replay.user, id, context.abortSignal).catch(
|
|
111
|
+
(error) => {
|
|
112
|
+
if (context.abortSignal?.aborted) throw error;
|
|
113
|
+
return messageOf(error);
|
|
114
|
+
}
|
|
115
|
+
);
|
|
116
|
+
if (typeof place === "string")
|
|
117
|
+
return edit(runtime, id, (kept) => ended(kept, "failed", now(host), place), DONE, context);
|
|
118
|
+
return edit(
|
|
119
|
+
runtime,
|
|
120
|
+
id,
|
|
121
|
+
(kept) => Object.assign(kept, place),
|
|
122
|
+
next({ phase: "call", server: host.server, boot: host.boot }),
|
|
123
|
+
context
|
|
124
|
+
);
|
|
125
|
+
}
|
|
126
|
+
async function adopt(id, boot, runtime, context) {
|
|
127
|
+
const host = await lookup();
|
|
128
|
+
const item = await itemOf(runtime, id, context);
|
|
129
|
+
const target = item?.replay?.target ?? "root";
|
|
130
|
+
let lead = await adoptable(host.kernel, runTag(id), target);
|
|
131
|
+
for (let attempt = 0; !lead && attempt < ADOPT_TRIES - 1; attempt++) {
|
|
132
|
+
await sleep((host.adoptMs ?? ADOPT_MS) * 2 ** attempt, context.abortSignal);
|
|
133
|
+
lead = await adoptable(host.kernel, runTag(id), target);
|
|
134
|
+
}
|
|
135
|
+
if (!lead)
|
|
136
|
+
return edit(
|
|
137
|
+
runtime,
|
|
138
|
+
id,
|
|
139
|
+
(kept) => ended(kept, "failed", now(host), RUN_ERRORS.interrupted),
|
|
140
|
+
DONE,
|
|
141
|
+
context
|
|
142
|
+
);
|
|
143
|
+
const pgid = lead.pgid ?? lead.pid;
|
|
144
|
+
return edit(
|
|
145
|
+
runtime,
|
|
146
|
+
id,
|
|
147
|
+
(kept) => Object.assign(kept, { state: "running", pid: lead.pid, pgid }),
|
|
148
|
+
next({ phase: "started", pid: lead.pid, pgid, boot }),
|
|
149
|
+
context
|
|
150
|
+
);
|
|
151
|
+
}
|
|
152
|
+
async function call(id, at, runtime, context) {
|
|
153
|
+
const host = await lookup();
|
|
154
|
+
if (at.server !== host.server || calling.has(id)) return adopt(id, at.boot, runtime, context);
|
|
155
|
+
calling.add(id);
|
|
156
|
+
const item = await claimed(runtime, id, context);
|
|
157
|
+
if (!item) return;
|
|
158
|
+
const { run } = item;
|
|
159
|
+
if (run.stopBy)
|
|
160
|
+
return edit(runtime, id, (kept) => ended(kept, "stopped", now(host)), DONE, context);
|
|
161
|
+
await watcher(host, id);
|
|
162
|
+
let started;
|
|
163
|
+
try {
|
|
164
|
+
if (!host.kernel.sudoRun)
|
|
165
|
+
throw Object.assign(new Error(RUN_REASONS.kernel), { code: "ENOSYS" });
|
|
166
|
+
const asked = host.kernel.sudoRun(item.replay, {
|
|
167
|
+
stdout: run.stdout,
|
|
168
|
+
stderr: run.stderr,
|
|
169
|
+
tag: runTag(id)
|
|
170
|
+
});
|
|
171
|
+
started = await Promise.race([asked, aborted(context.abortSignal)]);
|
|
172
|
+
} catch (error) {
|
|
173
|
+
await release(id);
|
|
174
|
+
if (context.abortSignal?.aborted) throw error;
|
|
175
|
+
const why = messageOf(error);
|
|
176
|
+
return edit(runtime, id, (kept) => ended(kept, "failed", now(host), why), DONE, context);
|
|
177
|
+
}
|
|
178
|
+
ends.set(id, started.ended);
|
|
179
|
+
started.ended.catch(() => void 0);
|
|
180
|
+
const { pid, pgid } = started;
|
|
181
|
+
return edit(
|
|
182
|
+
runtime,
|
|
183
|
+
id,
|
|
184
|
+
(kept) => Object.assign(kept, { state: "running", pid, pgid }),
|
|
185
|
+
next({ phase: "started", pid, pgid, boot: at.boot }),
|
|
186
|
+
context
|
|
187
|
+
);
|
|
188
|
+
}
|
|
189
|
+
async function begun(id, at, runtime, context) {
|
|
190
|
+
const host = await lookup();
|
|
191
|
+
const item = await itemOf(runtime, id, context);
|
|
192
|
+
if (item?.run) {
|
|
193
|
+
await tell(host, startLick(host, item));
|
|
194
|
+
if (item.run.stopBy) await stopTree(host, id);
|
|
195
|
+
}
|
|
196
|
+
const { pid, pgid, boot } = at;
|
|
197
|
+
await runtime.commit(async () => next({ phase: "wait", pid, pgid, boot }), context);
|
|
198
|
+
}
|
|
199
|
+
return { prepare, call, begun };
|
|
200
|
+
}
|
|
201
|
+
function watchdog(host, id, paths, signal) {
|
|
202
|
+
const cap = host.outputCap ?? OUTPUT_CAP;
|
|
203
|
+
return (async () => {
|
|
204
|
+
for (; ; ) {
|
|
205
|
+
await sleep(host.pollMs ?? POLL_MS, signal);
|
|
206
|
+
if (await outputSize(host.kernel, paths) <= cap) continue;
|
|
207
|
+
await stopTree(host, id);
|
|
208
|
+
return cap;
|
|
209
|
+
}
|
|
210
|
+
})().catch(() => void 0);
|
|
211
|
+
}
|
|
212
|
+
function finishing(lookup, mem, swept) {
|
|
213
|
+
const { ends, watcher, release } = mem;
|
|
214
|
+
const now = nowOf;
|
|
215
|
+
async function exitOf(host, id, pid, paths, context) {
|
|
216
|
+
const seen = await watcher(host, id);
|
|
217
|
+
const end = ends.get(id)?.then(
|
|
218
|
+
(exit) => ({ status: exit.status, ...exit.signal ? { signal: exit.signal } : {} }),
|
|
219
|
+
() => new Promise(() => void 0)
|
|
220
|
+
);
|
|
221
|
+
const polling = new AbortController();
|
|
222
|
+
const signal = context.abortSignal;
|
|
223
|
+
const quit = () => polling.abort(signal?.reason);
|
|
224
|
+
signal?.addEventListener("abort", quit, { once: true });
|
|
225
|
+
if (signal?.aborted) quit();
|
|
226
|
+
const capped = watchdog(host, id, paths, polling.signal);
|
|
227
|
+
try {
|
|
228
|
+
const exit = await Promise.race([
|
|
229
|
+
seen.waitFor(pid),
|
|
230
|
+
...end ? [end] : [],
|
|
231
|
+
gone(host.kernel, pid, host.pollMs ?? POLL_MS, polling.signal)
|
|
232
|
+
]);
|
|
233
|
+
polling.abort();
|
|
234
|
+
return { exit, cap: await capped };
|
|
235
|
+
} finally {
|
|
236
|
+
signal?.removeEventListener("abort", quit);
|
|
237
|
+
polling.abort();
|
|
238
|
+
}
|
|
239
|
+
}
|
|
240
|
+
async function wait(id, at, runtime, context) {
|
|
241
|
+
const host = await lookup();
|
|
242
|
+
if (knownBoots(at.boot, host.boot) && at.boot !== host.boot) {
|
|
243
|
+
const left = await tagged(host.kernel, runTag(id));
|
|
244
|
+
if (left?.length)
|
|
245
|
+
return runtime.commit(async () => next({ ...at, phase: "wait", boot: host.boot }), context);
|
|
246
|
+
await release(id);
|
|
247
|
+
return edit(
|
|
248
|
+
runtime,
|
|
249
|
+
id,
|
|
250
|
+
(kept) => ended(kept, "failed", now(host), RUN_ERRORS.reloaded),
|
|
251
|
+
next({ phase: "ended" }),
|
|
252
|
+
context
|
|
253
|
+
);
|
|
254
|
+
}
|
|
255
|
+
try {
|
|
256
|
+
const item = await itemOf(runtime, id, context);
|
|
257
|
+
const paths = [item?.run?.stdout, item?.run?.stderr].filter((path) => !!path);
|
|
258
|
+
const { exit, cap } = await exitOf(host, id, at.pid, paths, context);
|
|
259
|
+
const left = (await tagged(host.kernel, runTag(id)) ?? []).map((row) => row.pid).filter((pid) => pid !== at.pid);
|
|
260
|
+
await edit(
|
|
261
|
+
runtime,
|
|
262
|
+
id,
|
|
263
|
+
(kept) => {
|
|
264
|
+
ended(kept, kept.stopBy || cap ? "stopped" : "done", now(host));
|
|
265
|
+
if (exit.status !== void 0) kept.status = exit.status;
|
|
266
|
+
if (exit.signal) kept.signal = exit.signal;
|
|
267
|
+
if (cap) kept.capped = cap;
|
|
268
|
+
if (left.length) kept.survivors = left;
|
|
269
|
+
},
|
|
270
|
+
next({ phase: "ended" }),
|
|
271
|
+
context
|
|
272
|
+
);
|
|
273
|
+
} finally {
|
|
274
|
+
await release(id);
|
|
275
|
+
}
|
|
276
|
+
}
|
|
277
|
+
async function report(id, runtime, context) {
|
|
278
|
+
const host = await lookup();
|
|
279
|
+
const item = await itemOf(runtime, id, context);
|
|
280
|
+
if (item?.run) await tell(host, endLick(host, item));
|
|
281
|
+
const lingering = !!item?.run?.survivors?.length;
|
|
282
|
+
await runtime.commit(async () => lingering ? next({ phase: "linger" }) : DONE, context);
|
|
283
|
+
if (!lingering) swept(host);
|
|
284
|
+
}
|
|
285
|
+
async function abort(id, runtime, context) {
|
|
286
|
+
const host = await lookup();
|
|
287
|
+
const item = await itemOf(runtime, id, context);
|
|
288
|
+
if (item && (runLive(item) || item.run?.survivors?.length)) await stopTree(host, id);
|
|
289
|
+
await release(id);
|
|
290
|
+
await runtime.commit(async (tx) => {
|
|
291
|
+
const kept = sudoIn((await tx.doc(ApprovalsDoc)).items, id);
|
|
292
|
+
if (kept?.run && runLive(kept)) ended(kept.run, "stopped", now(host));
|
|
293
|
+
return { status: "terminal", outcome: { status: "aborted" } };
|
|
294
|
+
}, context);
|
|
295
|
+
const after = await itemOf(runtime, id, context);
|
|
296
|
+
if (after?.run?.pid) await tell(host, endLick(host, after));
|
|
297
|
+
}
|
|
298
|
+
return { wait, report, abort };
|
|
299
|
+
}
|
|
300
|
+
async function linger(lookup, swept, id, runtime, context) {
|
|
301
|
+
const host = await lookup();
|
|
302
|
+
const item = await itemOf(runtime, id, context);
|
|
303
|
+
let shown = (item?.run?.survivors ?? []).join(",");
|
|
304
|
+
for (; ; ) {
|
|
305
|
+
await sleep(host.pollMs ?? POLL_MS, context.abortSignal);
|
|
306
|
+
const rows = await tagged(host.kernel, runTag(id));
|
|
307
|
+
if (!rows) continue;
|
|
308
|
+
const pids = rows.map((row) => row.pid);
|
|
309
|
+
if (pids.join(",") === shown) continue;
|
|
310
|
+
shown = pids.join(",");
|
|
311
|
+
const done = !pids.length;
|
|
312
|
+
await edit(
|
|
313
|
+
runtime,
|
|
314
|
+
id,
|
|
315
|
+
(kept) => {
|
|
316
|
+
if (done) delete kept.survivors;
|
|
317
|
+
else kept.survivors = pids;
|
|
318
|
+
},
|
|
319
|
+
done ? DONE : void 0,
|
|
320
|
+
context
|
|
321
|
+
);
|
|
322
|
+
if (!done) continue;
|
|
323
|
+
swept(host);
|
|
324
|
+
return;
|
|
325
|
+
}
|
|
326
|
+
}
|
|
327
|
+
function sweeper() {
|
|
328
|
+
let timer;
|
|
329
|
+
const sweep = async (host) => {
|
|
330
|
+
if (timer) clearTimeout(timer);
|
|
331
|
+
timer = void 0;
|
|
332
|
+
const keep = host.keepMs ?? KEEP_MS;
|
|
333
|
+
const at = nowOf(host);
|
|
334
|
+
const items = (await host.harness.snapshot(ApprovalsDoc, BACKGROUND_CONTEXT))?.items ?? [];
|
|
335
|
+
const kept = items.filter(
|
|
336
|
+
(item) => item.kind === "sudo" && !!item.run?.stdout && !item.run.removed && item.run.endedAt !== void 0 && !runLive(item) && !item.run.survivors?.length
|
|
337
|
+
);
|
|
338
|
+
const due = kept.filter((item) => at - item.run.endedAt >= keep);
|
|
339
|
+
for (const item of due) {
|
|
340
|
+
const paths = [item.run.stdout, item.run.stderr].filter((path) => !!path);
|
|
341
|
+
const user = item.replay?.user;
|
|
342
|
+
if (user) await removeOutput(host.kernel, user, paths);
|
|
343
|
+
}
|
|
344
|
+
if (due.length)
|
|
345
|
+
await host.harness.commit(async (tx) => {
|
|
346
|
+
for (const item of due) {
|
|
347
|
+
const found = sudoIn((await tx.doc(ApprovalsDoc)).items, item.id)?.run;
|
|
348
|
+
if (!found) continue;
|
|
349
|
+
delete found.stdout;
|
|
350
|
+
delete found.stderr;
|
|
351
|
+
found.removed = true;
|
|
352
|
+
}
|
|
353
|
+
}, BACKGROUND_CONTEXT);
|
|
354
|
+
const later = kept.filter((item) => !due.includes(item)).map((item) => item.run.endedAt + keep - at);
|
|
355
|
+
if (!later.length) return;
|
|
356
|
+
timer = setTimeout(
|
|
357
|
+
() => void sweep(host).catch(() => void 0),
|
|
358
|
+
Math.min(MAX_DELAY, Math.max(0, Math.min(...later)))
|
|
359
|
+
);
|
|
360
|
+
timer.unref?.();
|
|
361
|
+
};
|
|
362
|
+
return (host) => void sweep(host).catch(() => void 0);
|
|
363
|
+
}
|
|
364
|
+
function sudoRuns() {
|
|
365
|
+
let bind = () => void 0;
|
|
366
|
+
let held;
|
|
367
|
+
const bound = new Promise((resolve) => {
|
|
368
|
+
bind = (host) => {
|
|
369
|
+
held = host;
|
|
370
|
+
resolve(host);
|
|
371
|
+
};
|
|
372
|
+
});
|
|
373
|
+
const swept = sweeper();
|
|
374
|
+
const mem = memory();
|
|
375
|
+
const lookup = () => bound;
|
|
376
|
+
const run = {
|
|
377
|
+
...starting(lookup, mem),
|
|
378
|
+
...finishing(lookup, mem, swept),
|
|
379
|
+
linger: (id, runtime, context) => linger(lookup, swept, id, runtime, context)
|
|
380
|
+
};
|
|
381
|
+
const task = defineTask({
|
|
382
|
+
name: SUDO_RUN_TASK,
|
|
383
|
+
version: 1,
|
|
384
|
+
initial: () => ({ phase: "prepare" }),
|
|
385
|
+
phases: {
|
|
386
|
+
prepare: (task2, runtime, context) => run.prepare(task2.input.approval, runtime, context),
|
|
387
|
+
call: (task2, runtime, context) => run.call(task2.input.approval, task2.state.checkpoint, runtime, context),
|
|
388
|
+
started: (task2, runtime, context) => run.begun(task2.input.approval, task2.state.checkpoint, runtime, context),
|
|
389
|
+
wait: (task2, runtime, context) => run.wait(task2.input.approval, task2.state.checkpoint, runtime, context),
|
|
390
|
+
ended: (task2, runtime, context) => run.report(task2.input.approval, runtime, context),
|
|
391
|
+
linger: (task2, runtime, context) => run.linger(task2.input.approval, runtime, context)
|
|
392
|
+
},
|
|
393
|
+
abort: (task2, runtime, context) => run.abort(task2.input.approval, runtime, context)
|
|
394
|
+
});
|
|
395
|
+
return {
|
|
396
|
+
extension: defineExtension({ name: SUDO_RUNS, tasks: [task] }),
|
|
397
|
+
bind: (host) => {
|
|
398
|
+
bind(host);
|
|
399
|
+
swept(host);
|
|
400
|
+
},
|
|
401
|
+
async claim(id, runner, gates, context) {
|
|
402
|
+
const host = held;
|
|
403
|
+
if (!host) return { done: false, error: RUN_REASONS.kernel };
|
|
404
|
+
const at = host.now?.() ?? Date.now();
|
|
405
|
+
return host.harness.commit(async (tx) => {
|
|
406
|
+
const item = (await tx.doc(ApprovalsDoc)).items.find((entry) => entry.id === id);
|
|
407
|
+
if (!item) return { done: false, error: `There is no approval ${id}.` };
|
|
408
|
+
const able = runnable(item, at, gates);
|
|
409
|
+
if (able !== true) return { done: false, error: able.reason };
|
|
410
|
+
item.run = {
|
|
411
|
+
state: "starting",
|
|
412
|
+
by: runner.by,
|
|
413
|
+
...runner.device ? { device: runner.device } : {},
|
|
414
|
+
at
|
|
415
|
+
};
|
|
416
|
+
await tx.createTask(
|
|
417
|
+
task,
|
|
418
|
+
{ approval: id },
|
|
419
|
+
{
|
|
420
|
+
ownership: { kind: "conversation" },
|
|
421
|
+
conversationId: host.conversation,
|
|
422
|
+
background: true
|
|
423
|
+
}
|
|
424
|
+
);
|
|
425
|
+
return { done: true, error: null };
|
|
426
|
+
}, context);
|
|
427
|
+
},
|
|
428
|
+
async stop(id, runner, context) {
|
|
429
|
+
const host = held;
|
|
430
|
+
if (!host) return { done: false, error: RUN_ERRORS.idle };
|
|
431
|
+
const found = await host.harness.commit(async (tx) => {
|
|
432
|
+
const item = sudoIn((await tx.doc(ApprovalsDoc)).items, id);
|
|
433
|
+
if (!item?.run) return null;
|
|
434
|
+
const live = runLive(item);
|
|
435
|
+
if (live) item.run.stopBy = runner.by;
|
|
436
|
+
return { live, pid: item.run.pid };
|
|
437
|
+
}, context);
|
|
438
|
+
if (!found) return { done: false, error: RUN_ERRORS.idle };
|
|
439
|
+
if (found.live && found.pid === void 0) return { done: true, error: null };
|
|
440
|
+
const sent = await stopTree(host, id);
|
|
441
|
+
if (sent === "sent") return { done: true, error: null };
|
|
442
|
+
if (sent === "unknown") return { done: false, error: RUN_ERRORS.unseen };
|
|
443
|
+
return { done: false, error: found.live ? RUN_ERRORS.gone : RUN_ERRORS.idle };
|
|
444
|
+
}
|
|
445
|
+
};
|
|
446
|
+
}
|
|
447
|
+
export {
|
|
448
|
+
ADOPT_MS,
|
|
449
|
+
ADOPT_TRIES,
|
|
450
|
+
KEEP_MS,
|
|
451
|
+
KILL_MS,
|
|
452
|
+
OUTPUT_CAP,
|
|
453
|
+
POLL_MS,
|
|
454
|
+
RUNS_DIR,
|
|
455
|
+
RUN_ERRORS,
|
|
456
|
+
RUN_TAG,
|
|
457
|
+
SUDO_RUNS,
|
|
458
|
+
SUDO_RUN_TASK,
|
|
459
|
+
clock,
|
|
460
|
+
duration,
|
|
461
|
+
endLick2 as endLick,
|
|
462
|
+
messageOf,
|
|
463
|
+
outputOf2 as outputOf,
|
|
464
|
+
runTag2 as runTag,
|
|
465
|
+
startLick2 as startLick,
|
|
466
|
+
sudoRuns
|
|
467
|
+
};
|
|
468
|
+
//# sourceMappingURL=run.js.map
|