agentlane 0.5.0 → 0.6.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.
@@ -1,12 +1,16 @@
1
1
  import { DEVICE_NOUN } from "../devices/backend.js";
2
2
  import { names } from "./rows.js";
3
3
  import { int, optInt, optText, text } from "./store.js";
4
- export const NOTHING_TO_RESTART = { device: null, services: [], browser: null, app: null };
4
+ export const NOTHING_TO_RESTART = { device: null, services: [], shared: [], browser: null, app: null };
5
+ function strings(value) {
6
+ return Array.isArray(value) ? value.filter((s) => typeof s === 'string') : [];
7
+ }
5
8
  function restartsOf(raw) {
6
9
  const parsed = JSON.parse(raw);
7
10
  return {
8
11
  device: parsed.device ?? null,
9
- services: Array.isArray(parsed.services) ? parsed.services.filter((s) => typeof s === 'string') : [],
12
+ services: strings(parsed.services),
13
+ shared: strings(parsed.shared),
10
14
  browser: parsed.browser ?? null,
11
15
  app: typeof parsed.app === 'string' ? parsed.app : null,
12
16
  };
@@ -43,6 +47,7 @@ export function mergeRestarts(earlier, later) {
43
47
  return {
44
48
  device: later.device ?? earlier.device,
45
49
  services: [...new Set([...earlier.services, ...later.services])],
50
+ shared: [...new Set([...earlier.shared, ...later.shared])],
46
51
  browser: later.browser ?? earlier.browser,
47
52
  app: later.app ?? earlier.app,
48
53
  };
@@ -52,6 +57,7 @@ export function describeRestarts(restarts) {
52
57
  const { device } = restarts;
53
58
  const parts = [
54
59
  ...(device ? [`${DEVICE_NOUN[device.platform]} ${device.name} (${device.deviceTypeName}, ${device.runtimeName})`] : []),
60
+ ...(restarts.shared.length > 0 ? [`shared services ${restarts.shared.join(', ')}`] : []),
55
61
  ...(restarts.services.length > 0 ? [`services ${restarts.services.join(', ')}`] : []),
56
62
  ...(restarts.app ? [`the app ${restarts.app}`] : []),
57
63
  ...(restarts.browser ? [`the ${restarts.browser} browser`] : []),
@@ -13,10 +13,11 @@ import { dropPark, NOTHING_TO_RESTART, readPark, writePark } from "./parks.js";
13
13
  import { configPath, diskNames } from "./paths.js";
14
14
  import { deletePoolDevice, listPrunable } from "./prune.js";
15
15
  import { NotClaimed, Refusal, UsageError } from "./refusal.js";
16
- import { endTeardown, failResource, failTeardown, finishResource, holdersBeforeLock, pendingTeardowns, startResource, takeTeardowns, } from "./resources.js";
16
+ import { endTeardown, failResource, failTeardown, finishResource, followResourceNeeds, holdersBeforeLock, pendingTeardowns, startResource, takeTeardowns, } from "./resources.js";
17
17
  import { loadLane, ownerFromRow, processesOf } from "./rows.js";
18
- import { readStatus } from "./status.js";
19
- import { int, optInt, optText, Store, text } from "./store.js";
18
+ import { beginStart, beginStop, endCommand, failStart, failStop, finishStart, finishStop, laneActive, laneNeeds, markNeedsUnneeded, noteCommand, readShared, recordLaneNeeds, SHARED_IDLE_MS, SHARED_STOP_RETRY_MS, sharedHoldersBeforeLock, stopCandidates, } from "./shared.js";
19
+ import { readsAsIs, readStatus } from "./status.js";
20
+ import { int, optInt, optText, Store, text, UNIDENTIFIED } from "./store.js";
20
21
  export const STEPS = [
21
22
  'claim:inspected',
22
23
  'claim:locked',
@@ -1169,6 +1170,7 @@ export class Registry {
1169
1170
  const id = text(row, 'id');
1170
1171
  const device = db.prepare('SELECT name FROM devices WHERE claim_id = ?').get(id);
1171
1172
  const processes = processesOf(db, id);
1173
+ const needed = laneActive(readPark(db, id)) ? laneNeeds(db, id) : [];
1172
1174
  const ended = {
1173
1175
  id,
1174
1176
  owner: describeOwner(ownerFromRow(row)),
@@ -1186,8 +1188,17 @@ export class Registry {
1186
1188
  by_owner_key, by_label, by_worktree, ended_at)
1187
1189
  VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(id, text(row, 'owner_key'), ended.owner, ended.worktree, ended.device, reason, ended.createdAt, ended.lastUsedAt, ended.lastAction, by.key, by.label, by.worktree, now);
1188
1190
  db.prepare('DELETE FROM claims WHERE id = ?').run(id);
1191
+ markNeedsUnneeded(db, needed, now);
1189
1192
  return ended;
1190
1193
  }
1194
+ /** Writes a change to a lane's park, marking the shared services it needed as unneeded when it stops being active. */
1195
+ changePark(laneId, change) {
1196
+ const db = this.store.db;
1197
+ const needed = laneActive(readPark(db, laneId)) ? laneNeeds(db, laneId) : [];
1198
+ change();
1199
+ if (needed.length > 0 && !laneActive(readPark(db, laneId)))
1200
+ markNeedsUnneeded(db, needed, this.clock.now());
1201
+ }
1191
1202
  endAndLease(rows, reason, by, me, keeper) {
1192
1203
  const db = this.store.db;
1193
1204
  const now = this.clock.now();
@@ -1621,6 +1632,8 @@ export class Registry {
1621
1632
  return ended;
1622
1633
  }
1623
1634
  touch(ref, action) {
1635
+ if (this.store.actor.who === UNIDENTIFIED)
1636
+ this.store.actor = { ...this.store.actor, who: `${TOOL} ${action}, on lane ${ref.id}` };
1624
1637
  return this.store.write(() => {
1625
1638
  this.step('touch:locked');
1626
1639
  this.requireLane(ref);
@@ -1719,14 +1732,16 @@ export class Registry {
1719
1732
  const park = readPark(db, ref.id);
1720
1733
  if (park && park.state !== 'parked' && !this.heldByDead(park, dead))
1721
1734
  return null;
1722
- writePark(db, ref.id, {
1723
- state: 'parking',
1724
- since: this.clock.now(),
1725
- parkedAt: park?.parkedAt ?? null,
1726
- holder: me,
1727
- attempt,
1728
- restarts: park?.restarts ?? NOTHING_TO_RESTART,
1729
- problems: park?.problems ?? [],
1735
+ this.changePark(ref.id, () => {
1736
+ writePark(db, ref.id, {
1737
+ state: 'parking',
1738
+ since: this.clock.now(),
1739
+ parkedAt: park?.parkedAt ?? null,
1740
+ holder: me,
1741
+ attempt,
1742
+ restarts: park?.restarts ?? NOTHING_TO_RESTART,
1743
+ problems: park?.problems ?? [],
1744
+ });
1730
1745
  });
1731
1746
  return loadLane(db, ref.id);
1732
1747
  });
@@ -1738,10 +1753,12 @@ export class Registry {
1738
1753
  const park = readPark(db, ref.id);
1739
1754
  if (park?.state !== 'parking' || park.attempt !== attempt)
1740
1755
  return;
1741
- if (park.parkedAt === null)
1742
- dropPark(db, ref.id);
1743
- else
1744
- writePark(db, ref.id, { ...park, state: 'parked', since: this.clock.now(), holder: null, attempt: null });
1756
+ this.changePark(ref.id, () => {
1757
+ if (park.parkedAt === null)
1758
+ dropPark(db, ref.id);
1759
+ else
1760
+ writePark(db, ref.id, { ...park, state: 'parked', since: this.clock.now(), holder: null, attempt: null });
1761
+ });
1745
1762
  });
1746
1763
  }
1747
1764
  /**
@@ -1789,14 +1806,16 @@ export class Registry {
1789
1806
  kept.push(`kept ${NOUN[platform]} ${name}: this process has no ${NOUN[platform]} tool to shut it down`);
1790
1807
  }
1791
1808
  }
1792
- writePark(db, ref.id, {
1793
- state: 'parked',
1794
- since: now,
1795
- parkedAt: now,
1796
- holder: null,
1797
- attempt: null,
1798
- restarts,
1799
- problems: kept,
1809
+ this.changePark(ref.id, () => {
1810
+ writePark(db, ref.id, {
1811
+ state: 'parked',
1812
+ since: now,
1813
+ parkedAt: now,
1814
+ holder: null,
1815
+ attempt: null,
1816
+ restarts,
1817
+ problems: kept,
1818
+ });
1800
1819
  });
1801
1820
  return { parked: true, work: this.inWrite({ own, others }, me, keeper, notes, 'park:stopped-device') };
1802
1821
  });
@@ -1861,14 +1880,16 @@ export class Registry {
1861
1880
  if (park?.attempt !== attempt)
1862
1881
  return;
1863
1882
  const now = this.clock.now();
1864
- writePark(db, ref.id, {
1865
- ...park,
1866
- state: 'parked',
1867
- since: now,
1868
- parkedAt: park.parkedAt ?? now,
1869
- holder: null,
1870
- attempt: null,
1871
- problems,
1883
+ this.changePark(ref.id, () => {
1884
+ writePark(db, ref.id, {
1885
+ ...park,
1886
+ state: 'parked',
1887
+ since: now,
1888
+ parkedAt: park.parkedAt ?? now,
1889
+ holder: null,
1890
+ attempt: null,
1891
+ problems,
1892
+ });
1872
1893
  });
1873
1894
  });
1874
1895
  }
@@ -1925,25 +1946,35 @@ export class Registry {
1925
1946
  this.store.db.prepare('DELETE FROM process_alive WHERE claim_id = ? AND service = ?').run(ref.id, service);
1926
1947
  });
1927
1948
  }
1949
+ /**
1950
+ * Records on each of the lane's resources the shared services it needs now, besides those it recorded before, and the
1951
+ * lane's repository, for its teardown to start.
1952
+ */
1953
+ followResourceNeeds(ref, resources) {
1954
+ this.store.write(() => {
1955
+ const row = this.requireLane(ref);
1956
+ followResourceNeeds(this.store.db, { id: ref.id, repository: text(row, 'project_root') }, resources);
1957
+ });
1958
+ }
1928
1959
  /** Records what the resource's teardown needs before its create runs; `kept` when this lane already has it. */
1929
1960
  startResource(ref, spec) {
1930
1961
  const me = this.self();
1931
1962
  const holders = holdersBeforeLock(this.store.db, this.processes);
1932
1963
  return this.store.write(() => {
1933
1964
  const row = this.requireLane(ref);
1934
- return startResource(this.store.db, { id: ref.id, worktree: text(row, 'worktree') }, spec, me, holders, this.clock.now());
1965
+ return startResource(this.store.db, { id: ref.id, worktree: text(row, 'worktree'), repository: text(row, 'project_root') }, spec, me, holders, this.clock.now());
1935
1966
  });
1936
1967
  }
1937
1968
  finishResource(lane, name, exports) {
1938
1969
  const me = this.self();
1939
1970
  this.store.write(() => {
1940
- finishResource(this.store.db, lane, name, exports, me);
1971
+ finishResource(this.store.db, lane, name, exports, me, this.clock.now());
1941
1972
  });
1942
1973
  }
1943
1974
  failResource(lane, name, problem) {
1944
1975
  const me = this.self();
1945
1976
  this.store.write(() => {
1946
- failResource(this.store.db, lane, name, problem, me);
1977
+ failResource(this.store.db, lane, name, problem, me, this.clock.now());
1947
1978
  });
1948
1979
  }
1949
1980
  /** Leases the resources of ended lanes to this process for teardown, last created first. */
@@ -1955,7 +1986,7 @@ export class Registry {
1955
1986
  finishTeardown(lane, name) {
1956
1987
  const me = this.self();
1957
1988
  this.store.write(() => {
1958
- endTeardown(this.store.db, lane, name, me);
1989
+ endTeardown(this.store.db, lane, name, me, this.clock.now());
1959
1990
  });
1960
1991
  }
1961
1992
  failTeardown(lane, name, problem) {
@@ -1964,6 +1995,108 @@ export class Registry {
1964
1995
  failTeardown(this.store.db, lane, name, problem, me, this.clock.now());
1965
1996
  });
1966
1997
  }
1998
+ /**
1999
+ * Records the shared services the lane needs, by name: exactly `names`, from its resources' and services' `needs`.
2000
+ * While the lane is active, one it no longer needs counts as unneeded from now if no other active lane needs it.
2001
+ */
2002
+ recordNeeds(ref, names) {
2003
+ this.store.write(() => {
2004
+ const row = this.requireLane(ref);
2005
+ recordLaneNeeds(this.store.db, ref.id, text(row, 'project_root'), names, this.clock.now());
2006
+ });
2007
+ }
2008
+ /** The shared services the lane's record says it needs, by name. */
2009
+ needsOf(laneId) {
2010
+ return laneNeeds(this.store.db, laneId).map(n => n.name);
2011
+ }
2012
+ /**
2013
+ * Takes the start of shared service `name` for a lane, or for a teardown this process holds in `repository`, or says
2014
+ * who has it; see `beginStart`. A lane's start also records that the lane needs it.
2015
+ */
2016
+ beginSharedStart(need, name, spec, foundDown) {
2017
+ const me = this.self();
2018
+ const holders = sharedHoldersBeforeLock(this.store.db, this.processes);
2019
+ return this.store.write(() => {
2020
+ let whom;
2021
+ if ('lane' in need) {
2022
+ const row = this.requireLane(need.lane);
2023
+ whom = { kind: 'lane', repository: text(row, 'project_root'), lane: need.lane.id };
2024
+ }
2025
+ else
2026
+ whom = { kind: 'teardown', repository: need.repository };
2027
+ return beginStart(this.store.db, whom, name, spec, foundDown, me, holders, this.clock.now());
2028
+ });
2029
+ }
2030
+ /** Records the start this process holds as done; false when it no longer holds it. */
2031
+ finishSharedStart(key) {
2032
+ const me = this.self();
2033
+ return this.store.write(() => finishStart(this.store.db, key, me, this.clock.now()));
2034
+ }
2035
+ /** Records the start this process holds as failed; it stays recorded as running, with `problem`, for the sweep to stop. */
2036
+ failSharedStart(key, problem) {
2037
+ const me = this.self();
2038
+ this.store.write(() => {
2039
+ failStart(this.store.db, key, problem, me, this.clock.now());
2040
+ });
2041
+ }
2042
+ /**
2043
+ * Records the shell of the start or stop command this process runs for a shared service it holds, so a process taking
2044
+ * over once this one has died waits for that command. Nothing is recorded when the shell has already exited. Throws
2045
+ * when `ps` can't be read, or when this process no longer holds the shared service.
2046
+ */
2047
+ noteSharedCommand(key, pid) {
2048
+ const me = this.self();
2049
+ const table = this.processes.startTimes([pid]);
2050
+ if (!table)
2051
+ throw new Error(`could not read the start time of its shell, pid ${String(pid)}`);
2052
+ const start = table.get(pid);
2053
+ if (start === undefined)
2054
+ return;
2055
+ const noted = this.store.write(() => noteCommand(this.store.db, key, { pid, start }, me));
2056
+ if (!noted)
2057
+ throw new Error(`this process no longer holds shared service ${key.name}`);
2058
+ }
2059
+ /** Forgets the command this process recorded for a shared service, once it has ended. */
2060
+ endSharedCommand(key) {
2061
+ const me = this.self();
2062
+ this.store.write(() => {
2063
+ endCommand(this.store.db, key, me);
2064
+ });
2065
+ }
2066
+ /** The shared services a sweep may have to stop or mark, by one read of the registry; no process starts. */
2067
+ sharedStopCandidates() {
2068
+ const now = this.clock.now();
2069
+ return stopCandidates(this.store.db, now, { idleSince: now - SHARED_IDLE_MS, retrySince: now - SHARED_STOP_RETRY_MS });
2070
+ }
2071
+ /** Takes the stop of a shared service nothing has needed for SHARED_IDLE_MS, or says why it is left; see `beginStop`. */
2072
+ beginSharedStop(key) {
2073
+ const me = this.self();
2074
+ const holders = sharedHoldersBeforeLock(this.store.db, this.processes);
2075
+ return this.store.write(() => {
2076
+ this.store.actor = { who: `${TOOL} stopping shared service ${key.name}`, folder: key.repository };
2077
+ const now = this.clock.now();
2078
+ return beginStop(this.store.db, key, me, holders, now, {
2079
+ idleSince: now - SHARED_IDLE_MS,
2080
+ retrySince: now - SHARED_STOP_RETRY_MS,
2081
+ });
2082
+ });
2083
+ }
2084
+ finishSharedStop(key) {
2085
+ const me = this.self();
2086
+ this.store.write(() => {
2087
+ finishStop(this.store.db, key, me, this.clock.now());
2088
+ });
2089
+ }
2090
+ failSharedStop(key, problem) {
2091
+ const me = this.self();
2092
+ this.store.write(() => {
2093
+ failStop(this.store.db, key, problem, me, this.clock.now());
2094
+ });
2095
+ }
2096
+ /** Every shared service, with the lanes that need it, when it stops if none does, and its last problem. */
2097
+ sharedServices() {
2098
+ return readShared(this.store.db, this.clock.now());
2099
+ }
1967
2100
  /** The browsers of lanes that have ended, however they ended: their processes may still run. */
1968
2101
  endedBrowsers() {
1969
2102
  return this.store.db
@@ -2032,9 +2165,26 @@ function browserServices(request) {
2032
2165
  ? [debug, { name: BROWSER_STREAM_SERVICE, type: BROWSER_PORT_TYPE }]
2033
2166
  : [debug];
2034
2167
  }
2168
+ /** The shared services lane `laneId` needs, by name, as its record says; read without upgrading the registry. */
2169
+ export function readLaneNeeds(dir, laneId, lockWaitMs = DEFAULT_LOCK_WAIT_MS) {
2170
+ const store = Store.openToRead(dir, lockWaitMs);
2171
+ if (!store)
2172
+ return [];
2173
+ try {
2174
+ return store.lacking().includes('shared_needs') ? [] : laneNeeds(store.db, laneId).map(n => n.name);
2175
+ }
2176
+ finally {
2177
+ store.close();
2178
+ }
2179
+ }
2035
2180
  export function readRegistryStatus(options) {
2036
2181
  const config = options.config ?? loadConfig(options.dir);
2037
- const store = Store.openExisting(options.dir, options.lockWaitMs ?? DEFAULT_LOCK_WAIT_MS);
2182
+ const lockWaitMs = options.lockWaitMs ?? DEFAULT_LOCK_WAIT_MS;
2183
+ let store = Store.openToRead(options.dir, lockWaitMs);
2184
+ if (store && !readsAsIs(store.lacking())) {
2185
+ store.close();
2186
+ store = Store.openExisting(options.dir, lockWaitMs);
2187
+ }
2038
2188
  try {
2039
2189
  return readStatus(store, {
2040
2190
  dir: options.dir,
@@ -3,6 +3,7 @@ import { formatTime } from "./format.js";
3
3
  import { isProven, judgeProcess } from "./owner.js";
4
4
  import { Refusal } from "./refusal.js";
5
5
  import { names, optValues, values } from "./rows.js";
6
+ import { markUnneeded } from "./shared.js";
6
7
  import { int, optInt, optText, text } from "./store.js";
7
8
  export const TEARDOWN_RETRY_MS = 5 * 60_000;
8
9
  const ORPHANED = 'NOT EXISTS (SELECT 1 FROM claims c WHERE c.id = r.claim_id)';
@@ -42,6 +43,21 @@ function busy(row, spec) {
42
43
  },
43
44
  ], [`${CLI} up (again, once pid ${pid} has finished)`, `kill ${pid} (only if that process is hung)`]);
44
45
  }
46
+ function addNeeds(db, row, repository, needs) {
47
+ const kept = [...new Set([...needs, ...names(row, 'needs')])];
48
+ db.prepare('UPDATE resources SET repository = ?, needs = ? WHERE seq = ?').run(repository, JSON.stringify(kept), int(row, 'seq'));
49
+ }
50
+ /**
51
+ * Records on each of the lane's resources the shared services it needs now, besides those it recorded before, and the
52
+ * lane's repository, for its teardown to start.
53
+ */
54
+ export function followResourceNeeds(db, lane, resources) {
55
+ for (const resource of resources) {
56
+ const row = db.prepare('SELECT seq, needs FROM resources WHERE claim_id = ? AND name = ?').get(lane.id, resource.name);
57
+ if (row)
58
+ addNeeds(db, row, lane.repository, resource.needs);
59
+ }
60
+ }
45
61
  export function startResource(db, lane, spec, me, holders, now) {
46
62
  const row = db.prepare('SELECT * FROM resources WHERE claim_id = ? AND name = ?').get(lane.id, spec.name);
47
63
  if (row) {
@@ -49,22 +65,39 @@ export function startResource(db, lane, spec, me, holders, now) {
49
65
  if (held === 'held')
50
66
  throw busy(row, spec);
51
67
  const exports = optValues(row, 'exports');
52
- if (exports !== null && held === 'free')
68
+ if (exports !== null && held === 'free') {
69
+ addNeeds(db, row, lane.repository, spec.needs);
53
70
  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'));
71
+ }
72
+ db.prepare(`UPDATE resources SET cwd = ?, teardown = ?, timeout_ms = ?, env = ?, cleared = ?, repository = ?, needs = ?,
73
+ exports = NULL, problem = NULL WHERE seq = ?`).run(spec.cwd, spec.teardown, spec.timeoutMs, JSON.stringify(spec.env), JSON.stringify(spec.cleared), lane.repository, JSON.stringify(spec.needs), int(row, 'seq'));
55
74
  hold(db, int(row, 'seq'), me, now);
56
75
  return { kind: 'create', retry: optText(row, 'problem') ?? 'its last create did not finish' };
57
76
  }
58
- db.prepare(`INSERT INTO resources (claim_id, name, worktree, cwd, teardown, timeout_ms, env, cleared, created_at,
77
+ db.prepare(`INSERT INTO resources (claim_id, name, worktree, cwd, teardown, timeout_ms, env, cleared, repository, needs, created_at,
59
78
  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);
79
+ VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(lane.id, spec.name, lane.worktree, spec.cwd, spec.teardown, spec.timeoutMs, JSON.stringify(spec.env), JSON.stringify(spec.cleared), lane.repository, JSON.stringify(spec.needs), now, me.pid, me.start, now);
61
80
  return { kind: 'create', retry: null };
62
81
  }
63
- export function finishResource(db, lane, name, exports, me) {
82
+ /** The shared services a resource row `me` holds needs, read before the row is let go, so they can be marked unneeded after. */
83
+ function heldNeeds(db, lane, name, me) {
84
+ const row = db.prepare(`SELECT repository, needs FROM resources WHERE ${MINE}`).get(lane, name, me.pid, me.start);
85
+ const repository = row ? optText(row, 'repository') : null;
86
+ return row && repository !== null ? { repository, needs: names(row, 'needs') } : null;
87
+ }
88
+ function letGo(db, held, now) {
89
+ if (held)
90
+ markUnneeded(db, held.repository, held.needs, now);
91
+ }
92
+ export function finishResource(db, lane, name, exports, me, now) {
93
+ const held = heldNeeds(db, lane, name, me);
64
94
  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);
95
+ letGo(db, held, now);
65
96
  }
66
- export function failResource(db, lane, name, problem, me) {
97
+ export function failResource(db, lane, name, problem, me, now) {
98
+ const held = heldNeeds(db, lane, name, me);
67
99
  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);
100
+ letGo(db, held, now);
68
101
  }
69
102
  export function takeTeardowns(db, me, holders, now, choice) {
70
103
  const rows = choice.lane === undefined
@@ -82,11 +115,13 @@ export function takeTeardowns(db, me, holders, now, choice) {
82
115
  lane: text(row, 'claim_id'),
83
116
  name: text(row, 'name'),
84
117
  worktree: text(row, 'worktree'),
118
+ repository: optText(row, 'repository'),
85
119
  cwd: text(row, 'cwd'),
86
120
  teardown: text(row, 'teardown'),
87
121
  timeoutMs: int(row, 'timeout_ms'),
88
122
  env: values(row, 'env'),
89
123
  cleared: names(row, 'cleared'),
124
+ needs: names(row, 'needs'),
90
125
  exports: optValues(row, 'exports'),
91
126
  createdAt: int(row, 'created_at'),
92
127
  attempts: int(row, 'attempts'),
@@ -94,12 +129,16 @@ export function takeTeardowns(db, me, holders, now, choice) {
94
129
  }
95
130
  return taken;
96
131
  }
97
- export function endTeardown(db, lane, name, me) {
132
+ export function endTeardown(db, lane, name, me, now) {
133
+ const held = heldNeeds(db, lane, name, me);
98
134
  db.prepare(`DELETE FROM resources WHERE ${MINE}`).run(lane, name, me.pid, me.start);
135
+ letGo(db, held, now);
99
136
  }
100
137
  export function failTeardown(db, lane, name, problem, me, now) {
138
+ const held = heldNeeds(db, lane, name, me);
101
139
  db.prepare(`UPDATE resources SET attempts = attempts + 1, last_attempt_at = ?, problem = ?,
102
140
  holder_pid = NULL, holder_start = NULL, holder_since = NULL WHERE ${MINE}`).run(now, problem, lane, name, me.pid, me.start);
141
+ letGo(db, held, now);
103
142
  }
104
143
  export function pendingTeardowns(db) {
105
144
  return db