@clagentic/console 1.10.0 → 1.11.0-beta.1
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +14 -0
- package/bin/cli.js +15 -3
- package/lib/agents.js +1 -55
- package/lib/bash-auto-approve.js +133 -0
- package/lib/build-identity.js +23 -5
- package/lib/build-sha.json +2 -2
- package/lib/build-update-check.js +0 -62
- package/lib/build-update-offer.js +23 -13
- package/lib/build-update-restart.js +59 -43
- package/lib/cli/schedule-input-subcommands.js +327 -0
- package/lib/cli/session-subcommands.js +100 -17
- package/lib/client-build-id.js +56 -0
- package/lib/daemon.js +20 -5
- package/lib/injected-sender.js +225 -0
- package/lib/message-sender-record.js +133 -0
- package/lib/pending-prompts.js +55 -0
- package/lib/permission-mode-policy.js +63 -0
- package/lib/permission-summary.js +67 -0
- package/lib/project-connection.js +2 -1
- package/lib/project-external-trigger.js +9 -1
- package/lib/project-loop.js +26 -20
- package/lib/project-prompt-responses.js +20 -14
- package/lib/project-sessions.js +73 -21
- package/lib/project-user-message.js +18 -47
- package/lib/project.js +36 -62
- package/lib/public/app.js +3 -5
- package/lib/public/css/channel-layout.css +20 -0
- package/lib/public/css/diagnostics.css +7 -0
- package/lib/public/css/input.css +78 -0
- package/lib/public/css/menus.css +17 -0
- package/lib/public/modules/app-connection.js +18 -1
- package/lib/public/modules/app-messages.js +19 -17
- package/lib/public/modules/app-panels.js +9 -2
- package/lib/public/modules/app-rate-limit.js +63 -87
- package/lib/public/modules/app-rendering.js +37 -6
- package/lib/public/modules/at-agents.js +8 -0
- package/lib/public/modules/build-guard.js +61 -0
- package/lib/public/modules/build-update-detail.js +1 -4
- package/lib/public/modules/diagnostics.js +98 -9
- package/lib/public/modules/injected-identity.js +78 -0
- package/lib/public/modules/injected-label.js +62 -0
- package/lib/public/modules/input.js +64 -114
- package/lib/public/modules/mode-options.js +19 -16
- package/lib/public/modules/rate-limit-state.js +47 -22
- package/lib/public/modules/schedule-panel.js +234 -0
- package/lib/public/modules/schedule-time.js +193 -0
- package/lib/public/modules/scheduled-input-actions.js +19 -0
- package/lib/runtime-env.js +4 -0
- package/lib/scheduled-input/ipc.js +92 -0
- package/lib/scheduled-input/rate-limit-resume.js +53 -0
- package/lib/scheduled-input/records.js +350 -0
- package/lib/scheduled-input/service.js +743 -0
- package/lib/scheduled-input/store.js +132 -0
- package/lib/scheduled-input/ws.js +194 -0
- package/lib/sdk-bridge.js +137 -152
- package/lib/sdk-message-processor.js +13 -5
- package/lib/sdk-skill-discovery.js +17 -0
- package/lib/sender-ref.js +109 -0
- package/lib/server.js +28 -8
- package/lib/session-directory.js +224 -0
- package/lib/session-file-scan.js +55 -0
- package/lib/session-input-ipc.js +20 -0
- package/lib/session-input.js +355 -19
- package/lib/session-name-holder.js +82 -0
- package/lib/session-resume.js +1 -0
- package/lib/sessions.js +44 -0
- package/lib/turn-initiator.js +6 -2
- package/lib/ws-schema.js +15 -7
- package/lib/yoke/adapters/claude-worker.js +3 -1
- package/lib/yoke/adapters/claude.js +13 -7
- package/lib/yoke/adapters/codex.js +18 -5
- package/lib/yoke/adapters/permission-relay.js +9 -0
- package/lib/yoke/interface.js +7 -1
- package/package.json +1 -1
- package/scripts/check-test-count.js +1 -1
- package/scripts/install-local-test.js +45 -1
- package/scripts/postinstall.js +1 -0
|
@@ -0,0 +1,350 @@
|
|
|
1
|
+
// records.js - the shape of a scheduled input, the rules that change it, and
|
|
2
|
+
// which session it names. Pure: nothing here reads a clock or a file.
|
|
3
|
+
//
|
|
4
|
+
// One record type for both kinds:
|
|
5
|
+
// once fires one time, at `at`
|
|
6
|
+
// recurring fires every `every` ms, and always has an end: `until` (an
|
|
7
|
+
// absolute time) or `count` (a number of firings)
|
|
8
|
+
//
|
|
9
|
+
// A record is armed until it ends:
|
|
10
|
+
// done it ran its course (the once fired, or the until/count was reached)
|
|
11
|
+
// ended its session was closed or deleted before that
|
|
12
|
+
// Cancelling a record deletes it.
|
|
13
|
+
|
|
14
|
+
var crypto = require("crypto");
|
|
15
|
+
|
|
16
|
+
var KIND = Object.freeze({ ONCE: "once", RECURRING: "recurring" });
|
|
17
|
+
var STATE = Object.freeze({ ARMED: "armed", DONE: "done", ENDED: "ended" });
|
|
18
|
+
|
|
19
|
+
// How a record names its session. A session that has not run a turn yet has no
|
|
20
|
+
// vendor session id, only the console's own id, which is not stable across a
|
|
21
|
+
// daemon restart; such a record is upgraded once the id exists (see service.js).
|
|
22
|
+
var ID_KIND = Object.freeze({ VENDOR: "vendor", CONSOLE: "console" });
|
|
23
|
+
|
|
24
|
+
var LIMITS = Object.freeze({
|
|
25
|
+
MIN_EVERY_MS: 60 * 1000,
|
|
26
|
+
MAX_EVERY_MS: 24 * 60 * 60 * 1000,
|
|
27
|
+
MAX_ARMED_PER_SESSION: 5,
|
|
28
|
+
MAX_AHEAD_MS: 366 * 24 * 60 * 60 * 1000,
|
|
29
|
+
MAX_COUNT: 1000,
|
|
30
|
+
MAX_TEXT_CHARS: 50000,
|
|
31
|
+
MAX_NOTE_CHARS: 200,
|
|
32
|
+
});
|
|
33
|
+
|
|
34
|
+
// A time or a duration in ms: a positive whole number a double holds exactly,
|
|
35
|
+
// so a rounded or negative value never becomes a schedule.
|
|
36
|
+
function isMs(value) {
|
|
37
|
+
return Number.isSafeInteger(value) && value > 0;
|
|
38
|
+
}
|
|
39
|
+
|
|
40
|
+
function isCount(value) {
|
|
41
|
+
return Number.isSafeInteger(value) && value >= 1 && value <= LIMITS.MAX_COUNT;
|
|
42
|
+
}
|
|
43
|
+
|
|
44
|
+
function newId() {
|
|
45
|
+
return "si_" + crypto.randomBytes(5).toString("hex");
|
|
46
|
+
}
|
|
47
|
+
|
|
48
|
+
function minutesText(ms) {
|
|
49
|
+
return Math.round(ms / 60000) + " min";
|
|
50
|
+
}
|
|
51
|
+
|
|
52
|
+
// spec: { sessionId, sessionIdKind, kind, text, note?, createdBy, at?, every?,
|
|
53
|
+
// until?, count? }
|
|
54
|
+
// ctx: { now, armedForSession, exemptFromCap? }
|
|
55
|
+
// Returns { record } or { error }.
|
|
56
|
+
function buildRecord(spec, ctx) {
|
|
57
|
+
var now = ctx.now;
|
|
58
|
+
if (spec.kind !== KIND.ONCE && spec.kind !== KIND.RECURRING) {
|
|
59
|
+
return { error: "kind must be " + KIND.ONCE + " or " + KIND.RECURRING };
|
|
60
|
+
}
|
|
61
|
+
if (typeof spec.sessionId !== "string" || !spec.sessionId) return { error: "a session id is required" };
|
|
62
|
+
if (typeof spec.text !== "string" || !spec.text.trim()) return { error: "the text to send must not be empty" };
|
|
63
|
+
if (spec.text.length > LIMITS.MAX_TEXT_CHARS) return { error: "the text is longer than " + LIMITS.MAX_TEXT_CHARS + " characters" };
|
|
64
|
+
var note = typeof spec.note === "string" ? spec.note.slice(0, LIMITS.MAX_NOTE_CHARS) : "";
|
|
65
|
+
if (!ctx.exemptFromCap && ctx.armedForSession >= LIMITS.MAX_ARMED_PER_SESSION) {
|
|
66
|
+
return { error: "this session already has " + LIMITS.MAX_ARMED_PER_SESSION + " armed scheduled inputs (the limit); cancel one first" };
|
|
67
|
+
}
|
|
68
|
+
|
|
69
|
+
var record = {
|
|
70
|
+
id: newId(),
|
|
71
|
+
sessionId: spec.sessionId,
|
|
72
|
+
sessionIdKind: spec.sessionIdKind === ID_KIND.CONSOLE ? ID_KIND.CONSOLE : ID_KIND.VENDOR,
|
|
73
|
+
kind: spec.kind,
|
|
74
|
+
text: spec.text,
|
|
75
|
+
note: note,
|
|
76
|
+
createdBy: typeof spec.createdBy === "string" && spec.createdBy ? spec.createdBy.slice(0, 120) : "unknown",
|
|
77
|
+
createdAt: now,
|
|
78
|
+
nextAt: null,
|
|
79
|
+
lastFiredAt: null,
|
|
80
|
+
lastOutcome: null,
|
|
81
|
+
firedCount: 0,
|
|
82
|
+
failures: 0,
|
|
83
|
+
state: STATE.ARMED,
|
|
84
|
+
endedAt: null,
|
|
85
|
+
endReason: null,
|
|
86
|
+
};
|
|
87
|
+
|
|
88
|
+
if (spec.kind === KIND.ONCE) {
|
|
89
|
+
if (!isMs(spec.at)) return { error: "a once input needs the time to send at" };
|
|
90
|
+
if (spec.at - now > LIMITS.MAX_AHEAD_MS) return { error: "a scheduled input can be at most 366 days ahead" };
|
|
91
|
+
if (spec.every !== undefined || spec.until !== undefined || spec.count !== undefined) {
|
|
92
|
+
return { error: "every, until and count belong to a recurring input" };
|
|
93
|
+
}
|
|
94
|
+
record.at = spec.at;
|
|
95
|
+
// A time that is already past fires on the next check rather than being lost.
|
|
96
|
+
record.nextAt = Math.max(spec.at, now);
|
|
97
|
+
return { record: record };
|
|
98
|
+
}
|
|
99
|
+
|
|
100
|
+
if (!isMs(spec.every) || spec.every <LIMITS.MIN_EVERY_MS || spec.every > LIMITS.MAX_EVERY_MS) {
|
|
101
|
+
return { error: "every must be between 1 minute and 24 hours" };
|
|
102
|
+
}
|
|
103
|
+
var hasUntil = spec.until !== undefined && spec.until !== null;
|
|
104
|
+
var hasCount = spec.count !== undefined && spec.count !== null;
|
|
105
|
+
if (hasUntil === hasCount) {
|
|
106
|
+
return { error: "a recurring input needs an end: give exactly one of until (a time) or count (a number of times)" };
|
|
107
|
+
}
|
|
108
|
+
record.every = spec.every;
|
|
109
|
+
record.nextAt = now + spec.every;
|
|
110
|
+
record.until = null;
|
|
111
|
+
record.count = null;
|
|
112
|
+
if (hasUntil) {
|
|
113
|
+
if (!isMs(spec.until)) return { error: "until must be a time" };
|
|
114
|
+
if (spec.until < record.nextAt) {
|
|
115
|
+
return { error: "until is before the first firing (" + minutesText(spec.every) + " from now); nothing would be sent" };
|
|
116
|
+
}
|
|
117
|
+
if (spec.until - now > LIMITS.MAX_AHEAD_MS) return { error: "until can be at most 366 days ahead" };
|
|
118
|
+
record.until = spec.until;
|
|
119
|
+
} else {
|
|
120
|
+
if (!isCount(spec.count)) {
|
|
121
|
+
return { error: "count must be a whole number from 1 to " + LIMITS.MAX_COUNT };
|
|
122
|
+
}
|
|
123
|
+
record.count = spec.count;
|
|
124
|
+
}
|
|
125
|
+
return { record: record };
|
|
126
|
+
}
|
|
127
|
+
|
|
128
|
+
function oneOf(table, value) {
|
|
129
|
+
return Object.keys(table).some(function (k) { return table[k] === value; });
|
|
130
|
+
}
|
|
131
|
+
|
|
132
|
+
function isText(v) {
|
|
133
|
+
return typeof v === "string";
|
|
134
|
+
}
|
|
135
|
+
|
|
136
|
+
function isNonEmptyText(v) {
|
|
137
|
+
return typeof v === "string" && v.length > 0;
|
|
138
|
+
}
|
|
139
|
+
|
|
140
|
+
function isTextOrNull(v) {
|
|
141
|
+
return v === null || typeof v === "string";
|
|
142
|
+
}
|
|
143
|
+
|
|
144
|
+
function isMsOrNull(v) {
|
|
145
|
+
return v === null || isMs(v);
|
|
146
|
+
}
|
|
147
|
+
|
|
148
|
+
// A counter the code adds to: anything but a safe integer >= 0 turns the sum
|
|
149
|
+
// into NaN and a limit comparison into a comparison that is never true.
|
|
150
|
+
function isTally(v) {
|
|
151
|
+
return Number.isSafeInteger(v) && v >= 0;
|
|
152
|
+
}
|
|
153
|
+
|
|
154
|
+
// Every field buildRecord writes, with the check a record read back from disk
|
|
155
|
+
// must pass for it. `kinds` limits a field to those kinds of record (absent: all
|
|
156
|
+
// kinds). A field added to buildRecord without a row here fails the test that
|
|
157
|
+
// compares the two, so the load check cannot fall behind the code that writes.
|
|
158
|
+
var RECORD_FIELDS = Object.freeze({
|
|
159
|
+
id: { check: isNonEmptyText },
|
|
160
|
+
sessionId: { check: isNonEmptyText },
|
|
161
|
+
sessionIdKind: { check: function (v) { return oneOf(ID_KIND, v); } },
|
|
162
|
+
kind: { check: function (v) { return oneOf(KIND, v); } },
|
|
163
|
+
text: { check: isText },
|
|
164
|
+
note: { check: isTextOrNull },
|
|
165
|
+
createdBy: { check: isText },
|
|
166
|
+
createdAt: { check: isMs },
|
|
167
|
+
// Only a finished record has no next time.
|
|
168
|
+
nextAt: { check: function (v, r) { return r.state === STATE.ARMED ? isMs(v) : isMsOrNull(v); } },
|
|
169
|
+
lastFiredAt: { check: isMsOrNull },
|
|
170
|
+
lastOutcome: { check: isTextOrNull },
|
|
171
|
+
firedCount: { check: isTally },
|
|
172
|
+
failures: { check: isTally },
|
|
173
|
+
state: { check: function (v) { return oneOf(STATE, v); } },
|
|
174
|
+
endedAt: { check: isMsOrNull },
|
|
175
|
+
endReason: { check: isTextOrNull },
|
|
176
|
+
at: { kinds: [KIND.ONCE], check: isMs },
|
|
177
|
+
every: { kinds: [KIND.RECURRING], check: isMs },
|
|
178
|
+
until: { kinds: [KIND.RECURRING], check: isMsOrNull },
|
|
179
|
+
count: { kinds: [KIND.RECURRING], check: function (v) { return v === null || isCount(v); } },
|
|
180
|
+
});
|
|
181
|
+
|
|
182
|
+
// Whether a record read back from disk has what firing it needs. A record that
|
|
183
|
+
// fails is not repaired or dropped: the store treats the whole file as unreadable
|
|
184
|
+
// so a future or damaged file is never overwritten.
|
|
185
|
+
function isValidRecord(r) {
|
|
186
|
+
if (!r || typeof r !== "object") return false;
|
|
187
|
+
var ok = Object.keys(RECORD_FIELDS).every(function (name) {
|
|
188
|
+
var field = RECORD_FIELDS[name];
|
|
189
|
+
if (field.kinds && field.kinds.indexOf(r.kind) === -1) return true;
|
|
190
|
+
return field.check(r[name], r);
|
|
191
|
+
});
|
|
192
|
+
if (!ok) return false;
|
|
193
|
+
// A recurring input always has an end, and exactly one.
|
|
194
|
+
return r.kind === KIND.ONCE || (r.until === null) !== (r.count === null);
|
|
195
|
+
}
|
|
196
|
+
|
|
197
|
+
function finish(record, state, reason, now) {
|
|
198
|
+
record.state = state;
|
|
199
|
+
record.endReason = reason;
|
|
200
|
+
record.endedAt = now;
|
|
201
|
+
record.nextAt = null;
|
|
202
|
+
return record;
|
|
203
|
+
}
|
|
204
|
+
|
|
205
|
+
// The input was delivered to its session at `now`. The next firing of a
|
|
206
|
+
// recurring input is the delivery time plus `every`, so a late or skipped
|
|
207
|
+
// firing is never made up.
|
|
208
|
+
function afterDelivery(record, now, outcome) {
|
|
209
|
+
record.lastFiredAt = now;
|
|
210
|
+
record.lastOutcome = outcome;
|
|
211
|
+
record.firedCount += 1;
|
|
212
|
+
record.failures = 0;
|
|
213
|
+
if (record.kind === KIND.ONCE) return finish(record, STATE.DONE, "sent", now);
|
|
214
|
+
if (record.count !== null && record.firedCount >= record.count) {
|
|
215
|
+
return finish(record, STATE.DONE, "reached " + record.count + " times", now);
|
|
216
|
+
}
|
|
217
|
+
record.nextAt = now + record.every;
|
|
218
|
+
if (record.until !== null && record.nextAt > record.until) {
|
|
219
|
+
return finish(record, STATE.DONE, "reached its end time", now);
|
|
220
|
+
}
|
|
221
|
+
return record;
|
|
222
|
+
}
|
|
223
|
+
|
|
224
|
+
// The fields a firing moves, so a firing that did not reach its session can put
|
|
225
|
+
// the record back as it was (the record is advanced and saved before delivery).
|
|
226
|
+
var ADVANCED_FIELDS = ["nextAt", "lastFiredAt", "lastOutcome", "firedCount", "failures", "state", "endedAt", "endReason"];
|
|
227
|
+
|
|
228
|
+
function snapshot(record) {
|
|
229
|
+
var saved = {};
|
|
230
|
+
ADVANCED_FIELDS.forEach(function (k) { saved[k] = record[k]; });
|
|
231
|
+
return saved;
|
|
232
|
+
}
|
|
233
|
+
|
|
234
|
+
function restore(record, saved) {
|
|
235
|
+
ADVANCED_FIELDS.forEach(function (k) { record[k] = saved[k]; });
|
|
236
|
+
return record;
|
|
237
|
+
}
|
|
238
|
+
|
|
239
|
+
// A recurring record whose end time passed while it waited (a daemon that was
|
|
240
|
+
// down, a session that was busy) is done without a late firing.
|
|
241
|
+
function pastItsEnd(record, now) {
|
|
242
|
+
return record.kind === KIND.RECURRING && record.until !== null && now > record.until;
|
|
243
|
+
}
|
|
244
|
+
|
|
245
|
+
function endReached(record, now) {
|
|
246
|
+
return finish(record, STATE.DONE, "reached its end time", now);
|
|
247
|
+
}
|
|
248
|
+
|
|
249
|
+
function sessionGone(record, now, reason) {
|
|
250
|
+
return finish(record, STATE.ENDED, reason, now);
|
|
251
|
+
}
|
|
252
|
+
|
|
253
|
+
function isArmed(record) {
|
|
254
|
+
return record.state === STATE.ARMED;
|
|
255
|
+
}
|
|
256
|
+
|
|
257
|
+
// --- Which session a record names ---
|
|
258
|
+
//
|
|
259
|
+
// A record is bound to one session and never moves. The stable name is the
|
|
260
|
+
// session's vendor session id (cliSessionId): it is what the console's store
|
|
261
|
+
// and send-input use, and it survives a daemon restart. The console's own id
|
|
262
|
+
// (localId) is a per-project counter that restarts at 1, so it can only name a
|
|
263
|
+
// session that has not run a turn yet (and so has no vendor id); service.js
|
|
264
|
+
// upgrades such a record as soon as the id exists.
|
|
265
|
+
|
|
266
|
+
// { sessionId, sessionIdKind } for a session object.
|
|
267
|
+
function targetOf(session) {
|
|
268
|
+
if (session.cliSessionId) return { sessionId: session.cliSessionId, sessionIdKind: ID_KIND.VENDOR };
|
|
269
|
+
return { sessionId: String(session.localId), sessionIdKind: ID_KIND.CONSOLE };
|
|
270
|
+
}
|
|
271
|
+
|
|
272
|
+
function recordIsFor(record, session) {
|
|
273
|
+
if (record.sessionIdKind === ID_KIND.VENDOR) {
|
|
274
|
+
return !!session.cliSessionId && record.sessionId === session.cliSessionId;
|
|
275
|
+
}
|
|
276
|
+
return record.sessionId === String(session.localId);
|
|
277
|
+
}
|
|
278
|
+
|
|
279
|
+
function sameTarget(record, target) {
|
|
280
|
+
return record.sessionId === target.sessionId && record.sessionIdKind === target.sessionIdKind;
|
|
281
|
+
}
|
|
282
|
+
|
|
283
|
+
// The session in memory a record names, or null.
|
|
284
|
+
function liveSessionOf(sm, record) {
|
|
285
|
+
var found = null;
|
|
286
|
+
sm.sessions.forEach(function (s) {
|
|
287
|
+
if (!found && recordIsFor(record, s)) found = s;
|
|
288
|
+
});
|
|
289
|
+
return found;
|
|
290
|
+
}
|
|
291
|
+
|
|
292
|
+
// The session in memory an id names: the vendor session id or the console id,
|
|
293
|
+
// as send-input accepts either. Null when none is held.
|
|
294
|
+
function liveSessionById(sm, id) {
|
|
295
|
+
var byVendor = null;
|
|
296
|
+
var byConsole = null;
|
|
297
|
+
sm.sessions.forEach(function (s) {
|
|
298
|
+
if (!byVendor && s.cliSessionId === id) byVendor = s;
|
|
299
|
+
if (!byConsole && String(s.localId) === id) byConsole = s;
|
|
300
|
+
});
|
|
301
|
+
return byVendor || byConsole;
|
|
302
|
+
}
|
|
303
|
+
|
|
304
|
+
// The fields a client or the CLI needs, without the text of a long prompt.
|
|
305
|
+
var PREVIEW_CHARS = 80;
|
|
306
|
+
function summarize(record) {
|
|
307
|
+
var text = record.text;
|
|
308
|
+
return {
|
|
309
|
+
id: record.id,
|
|
310
|
+
sessionId: record.sessionId,
|
|
311
|
+
kind: record.kind,
|
|
312
|
+
state: record.state,
|
|
313
|
+
preview: text.length > PREVIEW_CHARS ? text.slice(0, PREVIEW_CHARS) + "..." : text,
|
|
314
|
+
createdBy: record.createdBy,
|
|
315
|
+
at: record.at === undefined ? null : record.at,
|
|
316
|
+
nextAt: record.nextAt,
|
|
317
|
+
every: record.every === undefined ? null : record.every,
|
|
318
|
+
until: record.until === undefined ? null : record.until,
|
|
319
|
+
count: record.count === undefined ? null : record.count,
|
|
320
|
+
firedCount: record.firedCount,
|
|
321
|
+
lastFiredAt: record.lastFiredAt,
|
|
322
|
+
lastOutcome: record.lastOutcome,
|
|
323
|
+
endReason: record.endReason,
|
|
324
|
+
};
|
|
325
|
+
}
|
|
326
|
+
|
|
327
|
+
module.exports = {
|
|
328
|
+
KIND: KIND,
|
|
329
|
+
STATE: STATE,
|
|
330
|
+
ID_KIND: ID_KIND,
|
|
331
|
+
LIMITS: LIMITS,
|
|
332
|
+
buildRecord: buildRecord,
|
|
333
|
+
isValidRecord: isValidRecord,
|
|
334
|
+
RECORD_FIELDS: RECORD_FIELDS,
|
|
335
|
+
isMs: isMs,
|
|
336
|
+
isCount: isCount,
|
|
337
|
+
afterDelivery: afterDelivery,
|
|
338
|
+
snapshot: snapshot,
|
|
339
|
+
restore: restore,
|
|
340
|
+
pastItsEnd: pastItsEnd,
|
|
341
|
+
endReached: endReached,
|
|
342
|
+
sessionGone: sessionGone,
|
|
343
|
+
isArmed: isArmed,
|
|
344
|
+
summarize: summarize,
|
|
345
|
+
targetOf: targetOf,
|
|
346
|
+
recordIsFor: recordIsFor,
|
|
347
|
+
sameTarget: sameTarget,
|
|
348
|
+
liveSessionOf: liveSessionOf,
|
|
349
|
+
liveSessionById: liveSessionById,
|
|
350
|
+
};
|