agentlane 0.0.0 → 0.4.0-rc.2
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/CHANGELOG.md +118 -0
- package/LICENSE +27 -0
- package/README.md +167 -2
- package/dist/agents/claude-plugin.js +79 -0
- package/dist/agents/cli.js +258 -0
- package/dist/agents/detect.js +88 -0
- package/dist/agents/init.js +251 -0
- package/dist/agents/launcher.js +32 -0
- package/dist/agents/package.js +119 -0
- package/dist/agents/skills.js +59 -0
- package/dist/agents/toml.js +325 -0
- package/dist/agents/wiring-check.js +117 -0
- package/dist/agents/wiring.js +374 -0
- package/dist/bench/host.js +104 -0
- package/dist/bench/live.js +511 -0
- package/dist/bench/mcp-client.js +91 -0
- package/dist/bench/model.js +15 -0
- package/dist/bench/report.js +162 -0
- package/dist/bench/run.js +121 -0
- package/dist/bench/schedule.js +140 -0
- package/dist/bench/stats.js +59 -0
- package/dist/bench-cli.js +167 -0
- package/dist/browser/aria.js +184 -0
- package/dist/browser/control.js +203 -0
- package/dist/browser/env.js +118 -0
- package/dist/browser/evidence.js +44 -0
- package/dist/browser/install.js +361 -0
- package/dist/browser/kinds.js +10 -0
- package/dist/browser/lane-browser.js +224 -0
- package/dist/browser/libraries.js +56 -0
- package/dist/browser/paths.js +29 -0
- package/dist/browser/release.js +121 -0
- package/dist/browser/screen.js +19 -0
- package/dist/browser/signin.js +154 -0
- package/dist/browser/stop.js +163 -0
- package/dist/browser/tools.js +25 -0
- package/dist/cache/build.js +154 -0
- package/dist/cache/config.js +186 -0
- package/dist/cache/index.js +4 -0
- package/dist/cache/key.js +196 -0
- package/dist/cache/store.js +303 -0
- package/dist/cli.js +178 -0
- package/dist/clock.js +4 -0
- package/dist/devices/adb.js +160 -0
- package/dist/devices/android.js +214 -0
- package/dist/devices/backend.js +7 -0
- package/dist/devices/bundler.js +46 -0
- package/dist/devices/common.js +51 -0
- package/dist/devices/controls.js +65 -0
- package/dist/devices/dial.js +56 -0
- package/dist/devices/emulator.js +396 -0
- package/dist/devices/hygiene.js +202 -0
- package/dist/devices/index.js +5 -0
- package/dist/devices/launch.js +76 -0
- package/dist/devices/simctl.js +119 -0
- package/dist/devices/tools.js +1 -0
- package/dist/devices/variant.js +99 -0
- package/dist/devices/xcrun.js +265 -0
- package/dist/driver/absence.js +54 -0
- package/dist/driver/caller.js +51 -0
- package/dist/driver/client.js +312 -0
- package/dist/driver/diff.js +180 -0
- package/dist/driver/elements.js +70 -0
- package/dist/driver/engine-main.js +13 -0
- package/dist/driver/engine.js +499 -0
- package/dist/driver/errors.js +11 -0
- package/dist/driver/exec.js +66 -0
- package/dist/driver/failure.js +156 -0
- package/dist/driver/flow.js +94 -0
- package/dist/driver/idle.js +100 -0
- package/dist/driver/images.js +68 -0
- package/dist/driver/install.js +272 -0
- package/dist/driver/lock.js +101 -0
- package/dist/driver/look.js +223 -0
- package/dist/driver/maestro-child.js +194 -0
- package/dist/driver/maestro-runs.js +46 -0
- package/dist/driver/paths.js +105 -0
- package/dist/driver/pixels.js +144 -0
- package/dist/driver/plan.js +108 -0
- package/dist/driver/release.js +7 -0
- package/dist/driver/runner.js +42 -0
- package/dist/driver/selector.js +91 -0
- package/dist/driver/session.js +474 -0
- package/dist/driver/suggest.js +86 -0
- package/dist/driver/supervisor.js +251 -0
- package/dist/driver/tree.js +426 -0
- package/dist/driver-cli.js +865 -0
- package/dist/evidence/device.js +177 -0
- package/dist/evidence/evidence.js +304 -0
- package/dist/evidence/files.js +92 -0
- package/dist/hooks/env.js +81 -0
- package/dist/hooks/run.js +101 -0
- package/dist/mcp/server.js +69 -0
- package/dist/mcp/tools.js +246 -0
- package/dist/name.js +22 -0
- package/dist/plugin/aims.js +465 -0
- package/dist/plugin/conventions.js +73 -0
- package/dist/plugin/guard.js +163 -0
- package/dist/plugin/hook-cli.js +216 -0
- package/dist/plugin/session-name.js +28 -0
- package/dist/plugin/shell.js +254 -0
- package/dist/processes.js +77 -0
- package/dist/project/config.js +316 -0
- package/dist/project/schema.js +335 -0
- package/dist/project/validate.js +224 -0
- package/dist/registry/config.js +142 -0
- package/dist/registry/format.js +22 -0
- package/dist/registry/owner.js +265 -0
- package/dist/registry/paths.js +50 -0
- package/dist/registry/ports.js +26 -0
- package/dist/registry/prune.js +160 -0
- package/dist/registry/refusal.js +53 -0
- package/dist/registry/registry.js +1027 -0
- package/dist/registry/resources.js +117 -0
- package/dist/registry/rows.js +115 -0
- package/dist/registry/status.js +85 -0
- package/dist/registry/store.js +274 -0
- package/dist/registry/types.js +1 -0
- package/dist/registry-cli.js +544 -0
- package/dist/services/services.js +268 -0
- package/dist/services/system.js +189 -0
- package/dist/up/deps.js +1 -0
- package/dist/up/doctor.js +424 -0
- package/dist/up/exec.js +133 -0
- package/dist/up/lane-files.js +75 -0
- package/dist/up/lane-services.js +38 -0
- package/dist/up/maestro-env.js +172 -0
- package/dist/up/preflight.js +232 -0
- package/dist/up/release.js +148 -0
- package/dist/up/resources.js +178 -0
- package/dist/up/restart.js +87 -0
- package/dist/up/setup.js +28 -0
- package/dist/up/up.js +610 -0
- package/dist/up-cli.js +258 -0
- package/dist/usage.js +16 -0
- package/package.json +58 -3
- package/schema/agentlane.schema.json +675 -0
- package/skills/create-verification-skill/LICENSE +21 -0
- package/skills/create-verification-skill/SKILL.md +88 -0
- package/skills/dev-loop/LICENSE +21 -0
- package/skills/dev-loop/SKILL.md +61 -0
- package/skills/device/SKILL.md +8 -0
- package/skills/drive/SKILL.md +64 -0
- package/skills/maintain-verification-skill/LICENSE +21 -0
- package/skills/maintain-verification-skill/SKILL.md +42 -0
- package/skills/setup/SKILL.md +80 -0
|
@@ -0,0 +1,117 @@
|
|
|
1
|
+
import { CLI, TOOL } from "../name.js";
|
|
2
|
+
import { formatTime } from "./format.js";
|
|
3
|
+
import { isProven, judgeProcess } from "./owner.js";
|
|
4
|
+
import { Refusal } from "./refusal.js";
|
|
5
|
+
import { names, optValues, values } from "./rows.js";
|
|
6
|
+
import { int, optInt, optText, text } from "./store.js";
|
|
7
|
+
export const TEARDOWN_RETRY_MS = 5 * 60_000;
|
|
8
|
+
const ORPHANED = 'NOT EXISTS (SELECT 1 FROM claims c WHERE c.id = r.claim_id)';
|
|
9
|
+
function holderKey(seq, pid, start) {
|
|
10
|
+
return `${String(seq)}:${String(pid)}:${start}`;
|
|
11
|
+
}
|
|
12
|
+
export function holdersBeforeLock(db, processes) {
|
|
13
|
+
const seen = new Set();
|
|
14
|
+
const pids = [];
|
|
15
|
+
for (const row of db.prepare('SELECT seq, holder_pid, holder_start FROM resources WHERE holder_pid IS NOT NULL').all()) {
|
|
16
|
+
const pid = int(row, 'holder_pid');
|
|
17
|
+
seen.add(holderKey(int(row, 'seq'), pid, text(row, 'holder_start')));
|
|
18
|
+
pids.push(pid);
|
|
19
|
+
}
|
|
20
|
+
return { table: pids.length === 0 ? new Map() : processes.startTimes(pids), seen };
|
|
21
|
+
}
|
|
22
|
+
function holdOf(row, holders) {
|
|
23
|
+
const pid = optInt(row, 'holder_pid');
|
|
24
|
+
const start = optText(row, 'holder_start');
|
|
25
|
+
if (pid === null || start === null)
|
|
26
|
+
return 'free';
|
|
27
|
+
if (!holders.seen.has(holderKey(int(row, 'seq'), pid, start)))
|
|
28
|
+
return 'held';
|
|
29
|
+
return isProven(judgeProcess({ pid, start }, holders.table)) ? 'stale' : 'held';
|
|
30
|
+
}
|
|
31
|
+
function hold(db, seq, me, now) {
|
|
32
|
+
db.prepare('UPDATE resources SET holder_pid = ?, holder_start = ?, holder_since = ? WHERE seq = ?').run(me.pid, me.start, now, seq);
|
|
33
|
+
}
|
|
34
|
+
const MINE = 'claim_id = ? AND name = ? AND holder_pid = ? AND holder_start = ?';
|
|
35
|
+
function busy(row, spec) {
|
|
36
|
+
const pid = String(optInt(row, 'holder_pid') ?? 0);
|
|
37
|
+
return new Refusal('resource-busy', `resource ${spec.name} of lane ${text(row, 'claim_id')} is being created or torn down by pid ${pid}`, [
|
|
38
|
+
{
|
|
39
|
+
who: `pid ${pid}, another ${TOOL} run for this lane`,
|
|
40
|
+
folder: text(row, 'worktree'),
|
|
41
|
+
since: formatTime(optInt(row, 'holder_since') ?? int(row, 'created_at')),
|
|
42
|
+
},
|
|
43
|
+
], [`${CLI} up (again, once pid ${pid} has finished)`, `kill ${pid} (only if that process is hung)`]);
|
|
44
|
+
}
|
|
45
|
+
export function startResource(db, lane, spec, me, holders, now) {
|
|
46
|
+
const row = db.prepare('SELECT * FROM resources WHERE claim_id = ? AND name = ?').get(lane.id, spec.name);
|
|
47
|
+
if (row) {
|
|
48
|
+
const held = holdOf(row, holders);
|
|
49
|
+
if (held === 'held')
|
|
50
|
+
throw busy(row, spec);
|
|
51
|
+
const exports = optValues(row, 'exports');
|
|
52
|
+
if (exports !== null && held === 'free')
|
|
53
|
+
return { kind: 'kept', exports, createdAt: int(row, 'created_at') };
|
|
54
|
+
db.prepare('UPDATE resources SET cwd = ?, teardown = ?, timeout_ms = ?, env = ?, cleared = ?, exports = NULL, problem = NULL WHERE seq = ?').run(spec.cwd, spec.teardown, spec.timeoutMs, JSON.stringify(spec.env), JSON.stringify(spec.cleared), int(row, 'seq'));
|
|
55
|
+
hold(db, int(row, 'seq'), me, now);
|
|
56
|
+
return { kind: 'create', retry: optText(row, 'problem') ?? 'its last create did not finish' };
|
|
57
|
+
}
|
|
58
|
+
db.prepare(`INSERT INTO resources (claim_id, name, worktree, cwd, teardown, timeout_ms, env, cleared, created_at,
|
|
59
|
+
holder_pid, holder_start, holder_since)
|
|
60
|
+
VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(lane.id, spec.name, lane.worktree, spec.cwd, spec.teardown, spec.timeoutMs, JSON.stringify(spec.env), JSON.stringify(spec.cleared), now, me.pid, me.start, now);
|
|
61
|
+
return { kind: 'create', retry: null };
|
|
62
|
+
}
|
|
63
|
+
export function finishResource(db, lane, name, exports, me) {
|
|
64
|
+
db.prepare(`UPDATE resources SET exports = ?, problem = NULL, holder_pid = NULL, holder_start = NULL, holder_since = NULL WHERE ${MINE}`).run(JSON.stringify(exports), lane, name, me.pid, me.start);
|
|
65
|
+
}
|
|
66
|
+
export function failResource(db, lane, name, problem, me) {
|
|
67
|
+
db.prepare(`UPDATE resources SET problem = ?, holder_pid = NULL, holder_start = NULL, holder_since = NULL WHERE ${MINE}`).run(problem, lane, name, me.pid, me.start);
|
|
68
|
+
}
|
|
69
|
+
export function takeTeardowns(db, me, holders, now, choice) {
|
|
70
|
+
const rows = choice.lane === undefined
|
|
71
|
+
? db.prepare(`SELECT * FROM resources r WHERE ${ORPHANED} ORDER BY claim_id, seq DESC`).all()
|
|
72
|
+
: db.prepare(`SELECT * FROM resources r WHERE ${ORPHANED} AND claim_id = ? ORDER BY seq DESC`).all(choice.lane);
|
|
73
|
+
const taken = [];
|
|
74
|
+
for (const row of rows) {
|
|
75
|
+
if (holdOf(row, holders) === 'held')
|
|
76
|
+
continue;
|
|
77
|
+
const last = optInt(row, 'last_attempt_at');
|
|
78
|
+
if (choice.lane === undefined && last !== null && now - last < TEARDOWN_RETRY_MS)
|
|
79
|
+
continue;
|
|
80
|
+
hold(db, int(row, 'seq'), me, now);
|
|
81
|
+
taken.push({
|
|
82
|
+
lane: text(row, 'claim_id'),
|
|
83
|
+
name: text(row, 'name'),
|
|
84
|
+
worktree: text(row, 'worktree'),
|
|
85
|
+
cwd: text(row, 'cwd'),
|
|
86
|
+
teardown: text(row, 'teardown'),
|
|
87
|
+
timeoutMs: int(row, 'timeout_ms'),
|
|
88
|
+
env: values(row, 'env'),
|
|
89
|
+
cleared: names(row, 'cleared'),
|
|
90
|
+
exports: optValues(row, 'exports'),
|
|
91
|
+
createdAt: int(row, 'created_at'),
|
|
92
|
+
attempts: int(row, 'attempts'),
|
|
93
|
+
});
|
|
94
|
+
}
|
|
95
|
+
return taken;
|
|
96
|
+
}
|
|
97
|
+
export function endTeardown(db, lane, name, me) {
|
|
98
|
+
db.prepare(`DELETE FROM resources WHERE ${MINE}`).run(lane, name, me.pid, me.start);
|
|
99
|
+
}
|
|
100
|
+
export function failTeardown(db, lane, name, problem, me, now) {
|
|
101
|
+
db.prepare(`UPDATE resources SET attempts = attempts + 1, last_attempt_at = ?, problem = ?,
|
|
102
|
+
holder_pid = NULL, holder_start = NULL, holder_since = NULL WHERE ${MINE}`).run(now, problem, lane, name, me.pid, me.start);
|
|
103
|
+
}
|
|
104
|
+
export function pendingTeardowns(db) {
|
|
105
|
+
return db
|
|
106
|
+
.prepare(`SELECT * FROM resources r WHERE ${ORPHANED} ORDER BY created_at, seq`)
|
|
107
|
+
.all()
|
|
108
|
+
.map(row => ({
|
|
109
|
+
lane: text(row, 'claim_id'),
|
|
110
|
+
name: text(row, 'name'),
|
|
111
|
+
worktree: text(row, 'worktree'),
|
|
112
|
+
createdAt: int(row, 'created_at'),
|
|
113
|
+
attempts: int(row, 'attempts'),
|
|
114
|
+
lastAttemptAt: optInt(row, 'last_attempt_at'),
|
|
115
|
+
problem: optText(row, 'problem'),
|
|
116
|
+
}));
|
|
117
|
+
}
|
|
@@ -0,0 +1,115 @@
|
|
|
1
|
+
import { BROWSER_DEBUG_SERVICE, BROWSER_STREAM_SERVICE } from "../browser/kinds.js";
|
|
2
|
+
import { EMULATOR_SERVICE, emulatorSerial } from "./config.js";
|
|
3
|
+
import { int, optInt, optText, text } from "./store.js";
|
|
4
|
+
export function ownerFromRow(row) {
|
|
5
|
+
const pid = optInt(row, 'owner_pid');
|
|
6
|
+
const start = optText(row, 'owner_start');
|
|
7
|
+
return {
|
|
8
|
+
kind: text(row, 'owner_kind'),
|
|
9
|
+
process: pid !== null && start !== null ? { pid, start } : null,
|
|
10
|
+
sessionId: optText(row, 'owner_session'),
|
|
11
|
+
threadId: optText(row, 'owner_thread'),
|
|
12
|
+
};
|
|
13
|
+
}
|
|
14
|
+
export function deviceFromRow(row, consolePort) {
|
|
15
|
+
const id = optText(row, 'device_id');
|
|
16
|
+
if (id === null)
|
|
17
|
+
return null;
|
|
18
|
+
const platform = text(row, 'platform');
|
|
19
|
+
return {
|
|
20
|
+
platform,
|
|
21
|
+
id,
|
|
22
|
+
name: text(row, 'name'),
|
|
23
|
+
deviceType: text(row, 'device_type'),
|
|
24
|
+
deviceTypeName: text(row, 'device_type_name'),
|
|
25
|
+
runtime: text(row, 'runtime'),
|
|
26
|
+
runtimeName: text(row, 'runtime_name'),
|
|
27
|
+
serial: platform === 'android' && consolePort !== null ? emulatorSerial(consolePort) : null,
|
|
28
|
+
};
|
|
29
|
+
}
|
|
30
|
+
export function browserFromRow(row, ports) {
|
|
31
|
+
const debug = ports.find(p => p.service === BROWSER_DEBUG_SERVICE)?.port;
|
|
32
|
+
if (debug === undefined)
|
|
33
|
+
return null;
|
|
34
|
+
return {
|
|
35
|
+
driver: text(row, 'driver'),
|
|
36
|
+
session: text(row, 'session'),
|
|
37
|
+
debugPort: debug,
|
|
38
|
+
streamPort: ports.find(p => p.service === BROWSER_STREAM_SERVICE)?.port ?? null,
|
|
39
|
+
createdAt: int(row, 'created_at'),
|
|
40
|
+
};
|
|
41
|
+
}
|
|
42
|
+
export function endedFromHistory(row) {
|
|
43
|
+
return {
|
|
44
|
+
id: text(row, 'claim_id'),
|
|
45
|
+
owner: text(row, 'owner_label'),
|
|
46
|
+
worktree: text(row, 'worktree'),
|
|
47
|
+
device: optText(row, 'device'),
|
|
48
|
+
reason: text(row, 'reason'),
|
|
49
|
+
createdAt: int(row, 'created_at'),
|
|
50
|
+
lastUsedAt: int(row, 'last_used_at'),
|
|
51
|
+
lastAction: text(row, 'last_action'),
|
|
52
|
+
endedAt: int(row, 'ended_at'),
|
|
53
|
+
by: text(row, 'by_label'),
|
|
54
|
+
};
|
|
55
|
+
}
|
|
56
|
+
export function loadLane(db, id) {
|
|
57
|
+
const info = loadLaneInfo(db, id);
|
|
58
|
+
const row = db.prepare('SELECT token FROM claims WHERE id = ?').get(id);
|
|
59
|
+
return info && row ? { ...info, token: text(row, 'token') } : null;
|
|
60
|
+
}
|
|
61
|
+
export function loadLaneInfo(db, id) {
|
|
62
|
+
const row = db.prepare('SELECT * FROM claims WHERE id = ?').get(id);
|
|
63
|
+
if (!row)
|
|
64
|
+
return null;
|
|
65
|
+
const device = db.prepare('SELECT * FROM devices WHERE claim_id = ?').get(id);
|
|
66
|
+
const ports = db
|
|
67
|
+
.prepare('SELECT * FROM ports WHERE claim_id = ? ORDER BY port')
|
|
68
|
+
.all(id)
|
|
69
|
+
.map(p => ({ service: text(p, 'service'), type: text(p, 'type'), port: int(p, 'port') }));
|
|
70
|
+
const browser = db.prepare('SELECT * FROM browsers WHERE claim_id = ?').get(id);
|
|
71
|
+
return {
|
|
72
|
+
id,
|
|
73
|
+
owner: ownerFromRow(row),
|
|
74
|
+
ownerKey: text(row, 'owner_key'),
|
|
75
|
+
projectRoot: text(row, 'project_root'),
|
|
76
|
+
worktree: text(row, 'worktree'),
|
|
77
|
+
createdAt: int(row, 'created_at'),
|
|
78
|
+
lastUsedAt: int(row, 'last_used_at'),
|
|
79
|
+
lastAction: text(row, 'last_action'),
|
|
80
|
+
device: device ? deviceFromRow(device, ports.find(p => p.service === EMULATOR_SERVICE)?.port ?? null) : null,
|
|
81
|
+
browser: browser ? browserFromRow(browser, ports) : null,
|
|
82
|
+
ports,
|
|
83
|
+
processes: db
|
|
84
|
+
.prepare('SELECT * FROM processes WHERE claim_id = ? ORDER BY service')
|
|
85
|
+
.all(id)
|
|
86
|
+
.map(p => ({ service: text(p, 'service'), pid: int(p, 'pid'), start: text(p, 'start'), cwd: optText(p, 'cwd') })),
|
|
87
|
+
resources: db
|
|
88
|
+
.prepare('SELECT name, exports FROM resources WHERE claim_id = ? ORDER BY seq')
|
|
89
|
+
.all(id)
|
|
90
|
+
.map(r => ({ name: text(r, 'name'), exports: optValues(r, 'exports') })),
|
|
91
|
+
};
|
|
92
|
+
}
|
|
93
|
+
export function values(row, column) {
|
|
94
|
+
const parsed = JSON.parse(text(row, column));
|
|
95
|
+
if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) {
|
|
96
|
+
throw new Error(`registry column ${column} is not an object of values`);
|
|
97
|
+
}
|
|
98
|
+
const out = {};
|
|
99
|
+
for (const [key, value] of Object.entries(parsed)) {
|
|
100
|
+
if (typeof value !== 'string')
|
|
101
|
+
throw new Error(`registry column ${column} holds a value for ${key} that is not text`);
|
|
102
|
+
out[key] = value;
|
|
103
|
+
}
|
|
104
|
+
return out;
|
|
105
|
+
}
|
|
106
|
+
export function names(row, column) {
|
|
107
|
+
const parsed = JSON.parse(text(row, column));
|
|
108
|
+
if (!Array.isArray(parsed) || !parsed.every((n) => typeof n === 'string')) {
|
|
109
|
+
throw new Error(`registry column ${column} is not a list of names`);
|
|
110
|
+
}
|
|
111
|
+
return parsed;
|
|
112
|
+
}
|
|
113
|
+
export function optValues(row, column) {
|
|
114
|
+
return optText(row, column) === null ? null : values(row, column);
|
|
115
|
+
}
|
|
@@ -0,0 +1,85 @@
|
|
|
1
|
+
import { judgeProcess, ownerState, worktreeState } from "./owner.js";
|
|
2
|
+
import { pendingTeardowns } from "./resources.js";
|
|
3
|
+
import { endedFromHistory, loadLaneInfo } from "./rows.js";
|
|
4
|
+
import { int, optText, text } from "./store.js";
|
|
5
|
+
const RECENT_MS = 24 * 3_600_000;
|
|
6
|
+
export function readStatus(store, sources) {
|
|
7
|
+
const now = sources.clock.now();
|
|
8
|
+
const report = {
|
|
9
|
+
stateDir: sources.dir,
|
|
10
|
+
now,
|
|
11
|
+
config: sources.config,
|
|
12
|
+
lanes: [],
|
|
13
|
+
pool: [],
|
|
14
|
+
queue: [],
|
|
15
|
+
recent: [],
|
|
16
|
+
teardowns: [],
|
|
17
|
+
};
|
|
18
|
+
if (!store)
|
|
19
|
+
return report;
|
|
20
|
+
const db = store.db;
|
|
21
|
+
const lanes = db
|
|
22
|
+
.prepare('SELECT id FROM claims ORDER BY created_at')
|
|
23
|
+
.all()
|
|
24
|
+
.map(row => loadLaneInfo(db, text(row, 'id')))
|
|
25
|
+
.filter((c) => c !== null);
|
|
26
|
+
const table = sources.processes.startTimes(lanes.flatMap(c => (c.owner.process ? [c.owner.process.pid] : [])));
|
|
27
|
+
const listed = new Map();
|
|
28
|
+
for (const backend of Object.values(sources.devices)) {
|
|
29
|
+
if (db.prepare('SELECT 1 FROM devices WHERE platform = ? LIMIT 1').get(backend.platform) === undefined)
|
|
30
|
+
continue;
|
|
31
|
+
try {
|
|
32
|
+
listed.set(backend.platform, new Map(backend.list().map(d => [d.id, d])));
|
|
33
|
+
}
|
|
34
|
+
catch {
|
|
35
|
+
listed.set(backend.platform, null);
|
|
36
|
+
}
|
|
37
|
+
}
|
|
38
|
+
const stateOf = (platform, id) => {
|
|
39
|
+
const devices = listed.get(platform);
|
|
40
|
+
if (!devices)
|
|
41
|
+
return 'unknown';
|
|
42
|
+
const device = devices.get(id);
|
|
43
|
+
if (!device)
|
|
44
|
+
return 'missing';
|
|
45
|
+
return device.booted ? 'booted' : 'shutdown';
|
|
46
|
+
};
|
|
47
|
+
report.lanes = lanes.map((lane) => ({
|
|
48
|
+
...lane,
|
|
49
|
+
ownerState: ownerState(judgeProcess(lane.owner.process, table), worktreeState(lane.worktree)),
|
|
50
|
+
idleMs: now - lane.lastUsedAt,
|
|
51
|
+
deviceState: lane.device ? stateOf(lane.device.platform, lane.device.id) : null,
|
|
52
|
+
}));
|
|
53
|
+
report.pool = db
|
|
54
|
+
.prepare('SELECT * FROM devices ORDER BY created_at, name')
|
|
55
|
+
.all()
|
|
56
|
+
.map((row) => {
|
|
57
|
+
const platform = text(row, 'platform');
|
|
58
|
+
const id = optText(row, 'device_id');
|
|
59
|
+
return {
|
|
60
|
+
name: text(row, 'name'),
|
|
61
|
+
platform,
|
|
62
|
+
id,
|
|
63
|
+
deviceTypeName: text(row, 'device_type_name'),
|
|
64
|
+
runtimeName: text(row, 'runtime_name'),
|
|
65
|
+
laneId: optText(row, 'claim_id'),
|
|
66
|
+
state: id === null ? 'creating' : stateOf(platform, id),
|
|
67
|
+
};
|
|
68
|
+
});
|
|
69
|
+
report.queue = db
|
|
70
|
+
.prepare('SELECT * FROM queue ORDER BY ticket')
|
|
71
|
+
.all()
|
|
72
|
+
.map((row) => ({
|
|
73
|
+
ticket: int(row, 'ticket'),
|
|
74
|
+
owner: text(row, 'owner_label'),
|
|
75
|
+
worktree: text(row, 'worktree'),
|
|
76
|
+
enqueuedAt: int(row, 'enqueued_at'),
|
|
77
|
+
waiterPid: int(row, 'waiter_pid'),
|
|
78
|
+
}));
|
|
79
|
+
report.recent = db
|
|
80
|
+
.prepare('SELECT * FROM history WHERE ended_at >= ? ORDER BY seq DESC LIMIT 20')
|
|
81
|
+
.all(now - RECENT_MS)
|
|
82
|
+
.map(endedFromHistory);
|
|
83
|
+
report.teardowns = pendingTeardowns(db);
|
|
84
|
+
return report;
|
|
85
|
+
}
|
|
@@ -0,0 +1,274 @@
|
|
|
1
|
+
import fs from 'node:fs';
|
|
2
|
+
import { DatabaseSync } from 'node:sqlite';
|
|
3
|
+
import { TOOL } from "../name.js";
|
|
4
|
+
import { formatTime } from "./format.js";
|
|
5
|
+
import { databasePath, lockHolderPath } from "./paths.js";
|
|
6
|
+
import { Refusal, UsageError } from "./refusal.js";
|
|
7
|
+
export const SCHEMA_VERSION = 1;
|
|
8
|
+
const FORMAT_1_ADDITIONS = `
|
|
9
|
+
CREATE TABLE IF NOT EXISTS resources (
|
|
10
|
+
seq INTEGER PRIMARY KEY AUTOINCREMENT,
|
|
11
|
+
claim_id TEXT NOT NULL,
|
|
12
|
+
name TEXT NOT NULL,
|
|
13
|
+
worktree TEXT NOT NULL,
|
|
14
|
+
cwd TEXT NOT NULL,
|
|
15
|
+
teardown TEXT NOT NULL,
|
|
16
|
+
timeout_ms INTEGER NOT NULL,
|
|
17
|
+
env TEXT NOT NULL,
|
|
18
|
+
cleared TEXT NOT NULL,
|
|
19
|
+
exports TEXT,
|
|
20
|
+
created_at INTEGER NOT NULL,
|
|
21
|
+
holder_pid INTEGER,
|
|
22
|
+
holder_start TEXT,
|
|
23
|
+
holder_since INTEGER,
|
|
24
|
+
attempts INTEGER NOT NULL DEFAULT 0,
|
|
25
|
+
last_attempt_at INTEGER,
|
|
26
|
+
problem TEXT,
|
|
27
|
+
UNIQUE (claim_id, name),
|
|
28
|
+
CHECK ((holder_pid IS NULL) = (holder_start IS NULL) AND (holder_pid IS NULL) = (holder_since IS NULL))
|
|
29
|
+
) STRICT;
|
|
30
|
+
CREATE TABLE IF NOT EXISTS browsers (
|
|
31
|
+
claim_id TEXT PRIMARY KEY,
|
|
32
|
+
driver TEXT NOT NULL,
|
|
33
|
+
session TEXT NOT NULL UNIQUE,
|
|
34
|
+
worktree TEXT NOT NULL,
|
|
35
|
+
created_at INTEGER NOT NULL
|
|
36
|
+
) STRICT;
|
|
37
|
+
`;
|
|
38
|
+
const ADDED_TABLES = ['resources', 'browsers'];
|
|
39
|
+
const SCHEMA = `
|
|
40
|
+
CREATE TABLE claims (
|
|
41
|
+
id TEXT PRIMARY KEY,
|
|
42
|
+
token TEXT NOT NULL,
|
|
43
|
+
owner_key TEXT NOT NULL,
|
|
44
|
+
owner_kind TEXT NOT NULL,
|
|
45
|
+
owner_pid INTEGER,
|
|
46
|
+
owner_start TEXT,
|
|
47
|
+
owner_session TEXT,
|
|
48
|
+
owner_thread TEXT,
|
|
49
|
+
project_root TEXT NOT NULL,
|
|
50
|
+
worktree TEXT NOT NULL,
|
|
51
|
+
created_at INTEGER NOT NULL,
|
|
52
|
+
last_used_at INTEGER NOT NULL,
|
|
53
|
+
last_action TEXT NOT NULL,
|
|
54
|
+
UNIQUE (owner_key, worktree)
|
|
55
|
+
) STRICT;
|
|
56
|
+
CREATE TABLE ports (
|
|
57
|
+
port INTEGER PRIMARY KEY,
|
|
58
|
+
type TEXT NOT NULL,
|
|
59
|
+
service TEXT NOT NULL,
|
|
60
|
+
claim_id TEXT NOT NULL REFERENCES claims(id) ON DELETE CASCADE,
|
|
61
|
+
UNIQUE (claim_id, service)
|
|
62
|
+
) STRICT;
|
|
63
|
+
CREATE TABLE devices (
|
|
64
|
+
name TEXT PRIMARY KEY,
|
|
65
|
+
platform TEXT NOT NULL,
|
|
66
|
+
device_id TEXT UNIQUE,
|
|
67
|
+
device_type TEXT NOT NULL,
|
|
68
|
+
device_type_name TEXT NOT NULL,
|
|
69
|
+
runtime TEXT NOT NULL,
|
|
70
|
+
runtime_name TEXT NOT NULL,
|
|
71
|
+
creator_pid INTEGER,
|
|
72
|
+
creator_start TEXT,
|
|
73
|
+
claim_id TEXT UNIQUE REFERENCES claims(id) ON DELETE SET NULL,
|
|
74
|
+
created_at INTEGER NOT NULL,
|
|
75
|
+
CHECK ((device_id IS NULL) = (creator_pid IS NOT NULL)),
|
|
76
|
+
CHECK (device_id IS NOT NULL OR claim_id IS NULL)
|
|
77
|
+
) STRICT;
|
|
78
|
+
CREATE TABLE processes (
|
|
79
|
+
claim_id TEXT NOT NULL REFERENCES claims(id) ON DELETE CASCADE,
|
|
80
|
+
service TEXT NOT NULL,
|
|
81
|
+
pid INTEGER NOT NULL,
|
|
82
|
+
start TEXT NOT NULL,
|
|
83
|
+
cwd TEXT,
|
|
84
|
+
PRIMARY KEY (claim_id, service)
|
|
85
|
+
) STRICT;
|
|
86
|
+
CREATE TABLE queue (
|
|
87
|
+
ticket INTEGER PRIMARY KEY AUTOINCREMENT,
|
|
88
|
+
waiter_pid INTEGER NOT NULL,
|
|
89
|
+
waiter_start TEXT NOT NULL,
|
|
90
|
+
owner_key TEXT NOT NULL,
|
|
91
|
+
owner_label TEXT NOT NULL,
|
|
92
|
+
worktree TEXT NOT NULL,
|
|
93
|
+
enqueued_at INTEGER NOT NULL
|
|
94
|
+
) STRICT;
|
|
95
|
+
CREATE TABLE history (
|
|
96
|
+
seq INTEGER PRIMARY KEY AUTOINCREMENT,
|
|
97
|
+
claim_id TEXT NOT NULL,
|
|
98
|
+
owner_key TEXT NOT NULL,
|
|
99
|
+
owner_label TEXT NOT NULL,
|
|
100
|
+
worktree TEXT NOT NULL,
|
|
101
|
+
device TEXT,
|
|
102
|
+
reason TEXT NOT NULL,
|
|
103
|
+
created_at INTEGER NOT NULL,
|
|
104
|
+
last_used_at INTEGER NOT NULL,
|
|
105
|
+
last_action TEXT NOT NULL,
|
|
106
|
+
by_owner_key TEXT NOT NULL,
|
|
107
|
+
by_label TEXT NOT NULL,
|
|
108
|
+
by_worktree TEXT NOT NULL,
|
|
109
|
+
ended_at INTEGER NOT NULL
|
|
110
|
+
) STRICT;
|
|
111
|
+
`;
|
|
112
|
+
export function text(row, column) {
|
|
113
|
+
const value = row[column];
|
|
114
|
+
if (typeof value !== 'string')
|
|
115
|
+
throw new Error(`registry column ${column} is not text`);
|
|
116
|
+
return value;
|
|
117
|
+
}
|
|
118
|
+
export function int(row, column) {
|
|
119
|
+
const value = row[column];
|
|
120
|
+
if (typeof value !== 'number')
|
|
121
|
+
throw new Error(`registry column ${column} is not a number`);
|
|
122
|
+
return value;
|
|
123
|
+
}
|
|
124
|
+
export function optText(row, column) {
|
|
125
|
+
const value = row[column];
|
|
126
|
+
return typeof value === 'string' ? value : null;
|
|
127
|
+
}
|
|
128
|
+
export function optInt(row, column) {
|
|
129
|
+
const value = row[column];
|
|
130
|
+
return typeof value === 'number' ? value : null;
|
|
131
|
+
}
|
|
132
|
+
function isBusy(error) {
|
|
133
|
+
const errcode = error.errcode;
|
|
134
|
+
return typeof errcode === 'number' && (errcode & 0xff) === 5;
|
|
135
|
+
}
|
|
136
|
+
const pauseCell = new Int32Array(new SharedArrayBuffer(4));
|
|
137
|
+
function pause(ms) {
|
|
138
|
+
Atomics.wait(pauseCell, 0, 0, ms);
|
|
139
|
+
}
|
|
140
|
+
function untilFree(deadline, action, onTimeout) {
|
|
141
|
+
for (;;) {
|
|
142
|
+
try {
|
|
143
|
+
return action();
|
|
144
|
+
}
|
|
145
|
+
catch (error) {
|
|
146
|
+
if (!isBusy(error))
|
|
147
|
+
throw error;
|
|
148
|
+
if (Date.now() >= deadline)
|
|
149
|
+
throw onTimeout();
|
|
150
|
+
pause(5 + Math.floor(Math.random() * 20));
|
|
151
|
+
}
|
|
152
|
+
}
|
|
153
|
+
}
|
|
154
|
+
export class Store {
|
|
155
|
+
db;
|
|
156
|
+
dir;
|
|
157
|
+
lockWaitMs;
|
|
158
|
+
actor = { who: 'an unidentified caller', folder: process.cwd() };
|
|
159
|
+
constructor(dir, db, lockWaitMs) {
|
|
160
|
+
this.dir = dir;
|
|
161
|
+
this.db = db;
|
|
162
|
+
this.lockWaitMs = lockWaitMs;
|
|
163
|
+
}
|
|
164
|
+
static open(dir, lockWaitMs) {
|
|
165
|
+
fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
|
|
166
|
+
const db = new DatabaseSync(databasePath(dir), { timeout: Math.min(1000, lockWaitMs) });
|
|
167
|
+
const store = new Store(dir, db, lockWaitMs);
|
|
168
|
+
const deadline = Date.now() + lockWaitMs;
|
|
169
|
+
untilFree(deadline, () => {
|
|
170
|
+
db.exec('PRAGMA journal_mode = WAL');
|
|
171
|
+
}, () => store.busyRefusal());
|
|
172
|
+
db.exec('PRAGMA synchronous = NORMAL');
|
|
173
|
+
db.exec('PRAGMA foreign_keys = ON');
|
|
174
|
+
if (untilFree(deadline, () => store.version(), () => store.busyRefusal()) !== SCHEMA_VERSION)
|
|
175
|
+
store.migrate();
|
|
176
|
+
const added = untilFree(deadline, () => store.hasAdditions(), () => store.busyRefusal());
|
|
177
|
+
if (!added) {
|
|
178
|
+
store.write(() => {
|
|
179
|
+
store.db.exec(FORMAT_1_ADDITIONS);
|
|
180
|
+
});
|
|
181
|
+
}
|
|
182
|
+
return store;
|
|
183
|
+
}
|
|
184
|
+
static openExisting(dir, lockWaitMs) {
|
|
185
|
+
if (!fs.existsSync(databasePath(dir)))
|
|
186
|
+
return null;
|
|
187
|
+
return Store.open(dir, lockWaitMs);
|
|
188
|
+
}
|
|
189
|
+
close() {
|
|
190
|
+
this.db.close();
|
|
191
|
+
}
|
|
192
|
+
hasAdditions() {
|
|
193
|
+
const found = this.db
|
|
194
|
+
.prepare(`SELECT COUNT(*) AS n FROM sqlite_master WHERE type = 'table' AND name IN (${ADDED_TABLES.map(() => '?').join(', ')})`)
|
|
195
|
+
.get(...ADDED_TABLES);
|
|
196
|
+
return found !== undefined && int(found, 'n') === ADDED_TABLES.length;
|
|
197
|
+
}
|
|
198
|
+
version() {
|
|
199
|
+
const row = this.db.prepare('PRAGMA user_version').get();
|
|
200
|
+
return row ? int(row, 'user_version') : 0;
|
|
201
|
+
}
|
|
202
|
+
migrate() {
|
|
203
|
+
this.write(() => {
|
|
204
|
+
const version = this.version();
|
|
205
|
+
if (version === SCHEMA_VERSION)
|
|
206
|
+
return;
|
|
207
|
+
if (version > SCHEMA_VERSION) {
|
|
208
|
+
throw new UsageError(`${databasePath(this.dir)} is registry format ${String(version)}, newer than this ${TOOL} understands (${String(SCHEMA_VERSION)})`, `upgrade ${TOOL} to the version every project on this Mac uses`);
|
|
209
|
+
}
|
|
210
|
+
this.db.exec(SCHEMA);
|
|
211
|
+
this.db.exec(FORMAT_1_ADDITIONS);
|
|
212
|
+
this.db.exec(`PRAGMA user_version = ${String(SCHEMA_VERSION)}`);
|
|
213
|
+
});
|
|
214
|
+
}
|
|
215
|
+
write(body) {
|
|
216
|
+
untilFree(Date.now() + this.lockWaitMs, () => {
|
|
217
|
+
this.db.exec('BEGIN IMMEDIATE');
|
|
218
|
+
}, () => this.busyRefusal());
|
|
219
|
+
try {
|
|
220
|
+
this.recordHolder();
|
|
221
|
+
const result = body();
|
|
222
|
+
this.db.exec('COMMIT');
|
|
223
|
+
return result;
|
|
224
|
+
}
|
|
225
|
+
catch (error) {
|
|
226
|
+
if (this.db.isTransaction)
|
|
227
|
+
this.db.exec('ROLLBACK');
|
|
228
|
+
throw error;
|
|
229
|
+
}
|
|
230
|
+
}
|
|
231
|
+
recordHolder() {
|
|
232
|
+
const holder = {
|
|
233
|
+
pid: process.pid,
|
|
234
|
+
command: [TOOL, ...process.argv.slice(2)].join(' '),
|
|
235
|
+
who: this.actor.who,
|
|
236
|
+
folder: this.actor.folder,
|
|
237
|
+
since: Date.now(),
|
|
238
|
+
};
|
|
239
|
+
const file = lockHolderPath(this.dir);
|
|
240
|
+
const tmp = `${file}.${String(process.pid)}.tmp`;
|
|
241
|
+
try {
|
|
242
|
+
fs.writeFileSync(tmp, JSON.stringify(holder));
|
|
243
|
+
fs.renameSync(tmp, file);
|
|
244
|
+
}
|
|
245
|
+
catch {
|
|
246
|
+
fs.rmSync(tmp, { force: true });
|
|
247
|
+
}
|
|
248
|
+
}
|
|
249
|
+
readHolder() {
|
|
250
|
+
try {
|
|
251
|
+
return JSON.parse(fs.readFileSync(lockHolderPath(this.dir), 'utf8'));
|
|
252
|
+
}
|
|
253
|
+
catch {
|
|
254
|
+
return null;
|
|
255
|
+
}
|
|
256
|
+
}
|
|
257
|
+
busyRefusal() {
|
|
258
|
+
const holder = this.readHolder();
|
|
259
|
+
const waited = `${String(Math.round(this.lockWaitMs / 1000))}s`;
|
|
260
|
+
if (!holder) {
|
|
261
|
+
return new Refusal('registry-busy', `the registry in ${this.dir} stayed locked for ${waited}`, [{ who: 'a process that left no holder record', folder: this.dir, since: 'unknown' }], [`retry the same ${TOOL} command`, `lsof ${databasePath(this.dir)} (shows which process has the registry open)`]);
|
|
262
|
+
}
|
|
263
|
+
return new Refusal('registry-busy', `the registry in ${this.dir} stayed locked for ${waited}`, [
|
|
264
|
+
{
|
|
265
|
+
who: `${holder.who}, pid ${String(holder.pid)} running '${holder.command}'`,
|
|
266
|
+
folder: holder.folder,
|
|
267
|
+
since: formatTime(holder.since),
|
|
268
|
+
},
|
|
269
|
+
], [
|
|
270
|
+
`retry the same ${TOOL} command once pid ${String(holder.pid)} finishes`,
|
|
271
|
+
`kill ${String(holder.pid)} (only if that process is hung)`,
|
|
272
|
+
]);
|
|
273
|
+
}
|
|
274
|
+
}
|
|
@@ -0,0 +1 @@
|
|
|
1
|
+
export {};
|