Skip to content

Commit 62001cf

Browse files
thymikeeclaude
andauthored
refactor(record): derive session recording from the publication lifecycle (#1719)
* refactor(record): derive session recording from the publication lifecycle `SessionState.recordSession` stored an answer the script-publication aggregate already contained. Every writer set both, but nothing made them agree, and #1533 was the consequence: a `--save-script` ingress re-armed the flag behind an ABORTED status, and a bare `close` published a recording the caller had been told was aborted. That fix routed every write through one rule, which made the two agree without making disagreement unrepresentable. The field remained a second source of truth, and its doc comments had to carry the invariant that a type could enforce. Remove the field and derive the answer. `isRecordingPublication` reads recording off the lifecycle: ordinary authoring records only while ARMED; a repair transaction records for its whole lifetime, terminal statuses included. That last clause is deliberately exact rather than merely safe — `armRepairStep` armed the old flag and neither `abortRepair` nor `commitRepair` ever cleared it, so narrowing it would silently stop evidence capture for a committed repair. Whether it should is a real question, and a behavior change, so it is left alone here. What this buys, beyond one less field: - `buildNextOpenSession` and `finalizeOrdinaryCloseScript` make no recording decision at all now, so no surface can arm recording without moving the lifecycle that authorizes it. - The writer's publication gate is answered entirely by the aggregate. Its separate ABORTED check is gone: a terminal authoring lifecycle is already not recording, so one question replaces two that could disagree. - The R7 ownership ratchet drops from 23 writer-owned fields / 29 owner claims to 22 / 26, and the layering manifest loses the entry whose comment documented the smell ("deliberately set on its own by paths that record without arming a publication"). Behavior-preserving: the derivation reproduces what the flag held at every transition. The test fixtures that armed `recordSession` with no publication state described a shape production stopped producing at #1478; they now carry the lifecycle that causes recording. Co-Authored-By: Claude Opus 5 <[email protected]> Claude-Session: https://claude.ai/code/session_01PFW9gJqz1wEHoowkdd1nFW * test(close-script): flush queued event-log writes before removing the tmp root CI failed the Coverage lane with ENOTEMPTY removing the test's tmp root, in `afterEach` rather than in an assertion. `SessionStore.recordAction` QUEUES its event-log append (`queueEventLogWrite`) instead of writing it, and every close path in this file records an action. Nothing awaited that write, so `fs.rmSync(root, {recursive: true})` could race it: the pending append recreates `<root>/sessions/<name>/` while rmSync is walking, and the final rmdir fails ENOTEMPTY. It needs CI's parallel load to lose the race — the file passes 12/12 in isolation locally. Await `flushSessionEventLogWrites()` before removing. The hazard is latent in any test that records actions and then removes its tmp root; this fixes the file that failed rather than sweeping the pattern, which deserves its own change. Not added to the #1419 contention-retry list: that list requires a concrete spawn/wait mechanism named per entry, and this file has none. The race was a real teardown bug, not lane contention. Co-Authored-By: Claude Opus 5 <[email protected]> Claude-Session: https://claude.ai/code/session_01PFW9gJqz1wEHoowkdd1nFW * docs: correct ADR 0016 on recording vs publication for repair Review caught a real overstatement. The amendment claimed evidence capture and publication authorization are "the same question asked of the same state". That holds for ordinary authoring — ARMED both records and publishes, ABORTED and PUBLISHED do neither — but not for repair: `isRecordingPublication` is true for every repair status including `committed` and `aborted`, while the writer additionally applies `isRepairArmedWriteBlocked`, refusing a committed transaction and one that is not yet committable. State it as it is: both decisions derive from the same aggregate, but they remain distinct predicates, and collapsing them would republish a committed repair or commit an incomplete prefix. Co-Authored-By: Claude Opus 5 <[email protected]> Claude-Session: https://claude.ai/code/session_01PFW9gJqz1wEHoowkdd1nFW --------- Co-authored-by: Claude <[email protected]>
1 parent 1b2e786 commit 62001cf

41 files changed

Lines changed: 255 additions & 178 deletions

Some content is hidden

Large Commits have some content hidden by default. Use the searchbox below for content that may be hidden.

‎CHANGELOG.md‎

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -2,6 +2,7 @@
22

33
## Unreleased
44

5+
- Internal: session recording is now derived from the script-publication lifecycle instead of being stored beside it. `SessionState.recordSession` is removed; `isRecordingPublication` answers the question from the aggregate (ordinary authoring records only while ARMED, a repair transaction records for its whole lifetime). The stored flag was a second source of truth that handler surfaces set directly, which is how #1533's aborted-recording drift arose — no surface can now arm recording without moving the lifecycle that authorizes it, and the script writer's publication gate is answered entirely by the aggregate. Behavior-preserving: the derivation reproduces what the flag held at every transition.
56
- Fixed: a script recording aborted by a second `open` is no longer published by a later bare `close` (#1533). `open <app> --save-script` followed by a second successful `open` terminates the recording and warns "Script publication was aborted…", and `close --save-script` correctly refuses it with "Retry with plain close; it will tear down the session without writing." But when that second `open` itself carried `--save-script`, the flag re-armed recording behind the terminal status, and a bare `close` then wrote the full session log to disk — publishing a recording the caller had been told was aborted, and breaking the promise the refusal makes. An aborted authoring lifecycle is now terminal by construction: `--save-script` arms nothing on any surface that handles it — the re-open builder, the close finalizer, and the recorded-action ingress — and the script writer refuses the lifecycle from every path that reaches it (bare `close`, teardown, idle-reap, active publication). This also stops an aborted session from paying recording-time costs it can never publish: a re-opened aborted recording no longer keeps the direct iOS selector fast paths for `click` and `get` disabled. Armed recordings, published recordings, and every repair transaction are unaffected.
67
- `agent-device mcp` now serves the stateless MCP `2026-07-28` revision alongside the handshake-based revisions it already spoke, as the spec's "dual-era server". Modern clients probe `server/discover`, which advertises the supported revisions, the tools capability, and server identity; their requests declare a protocol version in `_meta`, and their results carry `resultType: "complete"` plus `_meta["io.modelcontextprotocol/serverInfo"]`. `tools/list` and `server/discover` now return the `ttlMs`/`cacheScope` cache hints, so a client can cache the 55-tool, ~223KB tool list for an hour instead of re-fetching it on every start; the list was already emitted in a deterministic (sorted) order, which is the other half of what makes it cacheable. Each revision is answered on its own wire contract: a request declaring `2025-11-25` or `2025-06-18` through modern framing still gets the legacy result shape, and `initialize` never agrees to `2026-07-28`, which has no handshake to establish. A declared revision this server does not implement is rejected with `UnsupportedProtocolVersionError` (`-32022`) naming the ones it does, rather than being served under a version the client did not ask for, and modern framing that omits its required `protocolVersion`/`clientCapabilities` metadata — or supplies a `clientInfo` that is not a valid `Implementation` — is rejected as invalid params. `initialize` and `ping` were removed in `2026-07-28`, so a modern-framed call to either is answered `-32601` rather than served inside a `resultType: "complete"` envelope. Responses to legacy clients are unchanged byte-for-byte — `initialize` and `ping` are still served, and no cache, `resultType`, or `_meta` field is added to their results. Nothing here affects the CLI, Node, or daemon surfaces: the stdio transport, the tool set, and every tool's input/output schema are untouched.
78
- Fixed: the MCP `initialize` handshake now answers with the protocol revision the client requested when it is one this server implements, instead of always answering `2025-11-25`. A client pinned to `2025-06-18` was told to speak a revision it had not asked for, which the lifecycle contract answers by disconnecting.

‎docs/adr/0016-active-session-script-publication.md‎

Lines changed: 40 additions & 11 deletions
Original file line numberDiff line numberDiff line change
@@ -107,9 +107,9 @@ fresh session is the only re-arming boundary.
107107
> naming `open --save-script` as the recovery; a plain `close` still tears the session down
108108
> without writing. This is distinct from
109109
> [#1533](https://github.com/callstack/agent-device/issues/1533), which is about an
110-
> already-ARMED-then-ABORTED session whose flag ingress re-enables `recordSession` and lets a
110+
> already-ARMED-then-ABORTED session whose flag ingress re-enabled recording and let a
111111
> *bare* `close` (no `--save-script` on the close itself) publish; that case is resolved by the
112-
> amendment below.
112+
> amendments below.
113113
114114
> **Amendment (#1533, shipped).** ABORTED terminality above was enforced only by
115115
> `abortAuthoringOnSecondOpen` clearing `session.recordSession` — inert by ordering, not by
@@ -121,15 +121,44 @@ fresh session is the only re-arming boundary.
121121
> message untrue.
122122
>
123123
> ABORTED is now terminal by construction. `--save-script` arms recording through one rule owned by
124-
> the publication projection (`recordSessionAfterSaveScriptFlag`), which answers "not recording"
125-
> for an ABORTED lifecycle on every surface that handles the flag — the re-open builder, the close
126-
> finalizer, and the recorded-action ingress — so the flag can no longer contradict the status.
127-
> Publication authorization is likewise the aggregate's to answer: the writer asks one
128-
> publication-blocked question covering not-recording, an uncommittable or committed repair, and an
129-
> ABORTED authoring lifecycle alike, so every path that reaches it (bare `close`, teardown,
130-
> idle-reap, active publication) refuses. ARMED and PUBLISHED lifecycles and every repair
131-
> transaction are unchanged; no state name, transition, or entry point in the lifecycle above is
132-
> added or altered.
124+
> the publication projection, which answers "not recording" for an ABORTED lifecycle on every
125+
> surface that handles the flag — the re-open builder, the close finalizer, and the recorded-action
126+
> ingress — so the flag can no longer contradict the status. Publication authorization is likewise
127+
> the aggregate's to answer: the writer asks one publication-blocked question covering
128+
> not-recording, an uncommittable or committed repair, and an ABORTED authoring lifecycle alike, so
129+
> every path that reaches it (bare `close`, teardown, idle-reap, active publication) refuses. ARMED
130+
> and PUBLISHED lifecycles and every repair transaction are unchanged; no state name, transition,
131+
> or entry point in the lifecycle above is added or altered.
132+
133+
> **Amendment (#1533 follow-up, shipped).** The rule above still relied on a stored
134+
> `SessionState.recordSession` that every writer had to set in step with the lifecycle. Routing the
135+
> writes through one place made the two agree; it did not make disagreement unrepresentable, and
136+
> the field remained a second source of truth for a question the aggregate already answered.
137+
>
138+
> Recording is now **derived**, not stored. `isRecordingPublication` reads it off the lifecycle —
139+
> ordinary authoring records only while ARMED; a repair transaction records for its whole lifetime,
140+
> terminal statuses included — and the field is gone. Three consequences worth stating, because
141+
> they are what the derivation buys:
142+
>
143+
> - No surface can arm recording without moving the lifecycle that authorizes it, so #1533's drift
144+
> is unrepresentable rather than guarded against. `buildNextOpenSession` and the close finalizer
145+
> make no recording decision at all now.
146+
> - The writer's publication gate is answered entirely by the aggregate. Its separate ABORTED check
147+
> is gone, because a terminal authoring lifecycle is already not recording — no second gate that
148+
> could disagree with the first about *authoring*.
149+
> - Evidence capture and publication authorization now derive from the same aggregate, but they
150+
> remain **distinct predicates**, and deliberately so. They coincide for ordinary authoring:
151+
> ARMED both records and publishes, ABORTED and PUBLISHED do neither. They do NOT coincide for
152+
> repair — `isRecordingPublication` is true for every repair status, `committed` and `aborted`
153+
> included, while publication additionally requires `isRepairArmedWriteBlocked` to pass, which
154+
> refuses a committed transaction (idempotent no-op) and one that is not yet committable (ADR
155+
> 0012 decision 6, C2). A repair that captures evidence is therefore not necessarily a repair
156+
> that may publish, and collapsing the two would silently republish or commit a prefix.
157+
>
158+
> This is behavior-preserving: the derivation reproduces exactly what the flag held at every
159+
> transition. Whether a *committed* repair should still capture recording-time evidence is a real
160+
> question this deliberately does not answer — the old flag said yes, and changing that is a
161+
> behavior change, not a derivation.
133162
134163
This lifecycle is distinct from ADR 0012's repair transaction. `session save-script` rejects a session
135164
with `saveScriptBoundary` set and directs the caller to finish or abort the repair through its existing

‎scripts/layering/daemon-modularity.ts‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -13,8 +13,8 @@ const LARGEST_TYPE_CYCLE_ZONE_CEILINGS: Readonly<Record<string, number>> = {
1313

1414
export const DAEMON_MODULARITY_BASELINE = {
1515
sessionState: {
16-
writerOwnedFields: 22,
17-
ownerFileClaims: 28,
16+
writerOwnedFields: 21,
17+
ownerFileClaims: 25,
1818
},
1919
largestTypeCycle: {
2020
zoneMembers: LARGEST_TYPE_CYCLE_ZONE_CEILINGS,

‎scripts/layering/session-state.ts‎

Lines changed: 3 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -56,18 +56,14 @@ export const SESSION_STATE_FIELD_OWNERS: Readonly<Record<string, readonly string
5656
// `saveScript*`/`scriptRecordingState`/`repair*` fields; its ONLY writers are the two
5757
// daemon-private projections (`session-replay-transaction.ts`,
5858
// `session-script-publication-capability.ts`) and the writer's commit transition.
59-
// `recordSession` is the broader "record actions" flag and is deliberately set on its own by
60-
// paths that record without arming a publication.
59+
// It also absorbed `recordSession`, whose separate ownership let handler surfaces arm
60+
// recording without moving the lifecycle that authorized it (#1533). Recording is now derived
61+
// (`isRecordingPublication`), so there is no second field to keep in step.
6162
scriptPublication: [
6263
'src/daemon/session-replay-transaction.ts',
6364
'src/daemon/session-script-publication-capability.ts',
6465
'src/daemon/session-script-writer.ts',
6566
],
66-
recordSession: [
67-
'src/daemon/handlers/session-close-script.ts',
68-
'src/daemon/session-replay-transaction.ts',
69-
'src/daemon/session-script-publication-capability.ts',
70-
],
7167
// #1478 P4b: moved from `session-replay-resume.ts` into the `ReplayCoordinator`
7268
// (`session-replay-coordinator.ts`) — the one locked gateway a native replay request uses to
7369
// reach both this watermark and the P4a `scriptPublication` transitions above.

‎src/__tests__/test-utils/session-factories.ts‎

Lines changed: 8 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -71,20 +71,25 @@ export function makeMacOsSession(name: string, overrides?: Partial<SessionState>
7171
// no recording, say) should still build it inline.
7272

7373
/**
74-
* ADR 0016 ordinary authoring recording: `recordSession` armed, NO repair
75-
* variant. This is a plain `open --save-script` / `close --save-script`
74+
* ADR 0016 ordinary authoring recording: the authoring lifecycle ARMED, NO
75+
* repair variant. This is a plain `open --save-script` / `close --save-script`
7676
* session, and the baseline for every authoring-side handler test (target-v1
7777
* evidence, parameterized fills, landmark waits) that only needs the session to
7878
* be recording its actions.
7979
*
80+
* ARMED is what makes it record. Recording is derived from the publication
81+
* lifecycle rather than stored beside it, so a session with no
82+
* `scriptPublication` records nothing — which is exactly what production does
83+
* for a session that never ran `open --save-script`.
84+
*
8085
* "Authoring", not "recording": `session.recording` is the unrelated
8186
* screen-capture state.
8287
*/
8388
export function makeAuthoringSession(
8489
name: string,
8590
overrides?: Partial<SessionState>,
8691
): SessionState {
87-
return makeIosSession(name, { recordSession: true, ...overrides });
92+
return makeIosSession(name, { scriptPublication: authoringPublication('armed'), ...overrides });
8893
}
8994

9095
/**

‎src/daemon/__tests__/request-save-script-transports.test.ts‎

Lines changed: 6 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -1,3 +1,4 @@
1+
import { isSessionRecording } from '../session-script-publication-capability.ts';
12
import { createTestDeviceInventoryGateways } from '../../__tests__/test-utils/device-inventory-gateways.ts';
23
/**
34
* #1478 (P4-pre): raw-wire counterfactuals for the `flags.saveScript` seam.
@@ -193,8 +194,8 @@ for (const [transport, send] of TRANSPORTS) {
193194
// No handler work: the trace never started and no action was recorded.
194195
expect(session.trace).toBe(undefined);
195196
expect(session.actions).toEqual([]);
196-
// No arming: neither the recording marker nor the publication target moved.
197-
expect(session.recordSession).toBe(undefined);
197+
// No arming: no publication lifecycle, so the session records nothing.
198+
expect(isSessionRecording(session)).toBe(false);
198199
expect(session.scriptPublication).toBe(undefined);
199200
// No artifact: the write a later close/teardown would attempt publishes nothing.
200201
expect(sessionStore.writeSessionLog(session)).toEqual({ written: false });
@@ -207,7 +208,7 @@ for (const [transport, send] of TRANSPORTS) {
207208
expect(accepted.ok).toBe(true);
208209
expect(session.trace?.outPath).toMatch(/\.trace\.log$/);
209210
expect(session.actions.map((action) => action.command)).toEqual(['trace']);
210-
expect(session.recordSession).toBe(undefined);
211+
expect(isSessionRecording(session)).toBe(false);
211212
expect(listAdArtifacts(root)).toEqual([]);
212213
});
213214

@@ -269,7 +270,7 @@ test('a batch step cannot smuggle the flag onto a non-owner command', async (t)
269270
if (response.ok) return;
270271
expect(response.error.message).toMatch(UNSUPPORTED_MESSAGE);
271272
expect(session.trace).toBe(undefined);
272-
expect(session.recordSession).toBe(undefined);
273+
expect(isSessionRecording(session)).toBe(false);
273274
expect(listAdArtifacts(root)).toEqual([]);
274275
});
275276

@@ -285,7 +286,7 @@ test('an owner-armed session still records its target and publishes its script',
285286
flags: { saveScript: target },
286287
result: { session: SESSION },
287288
});
288-
expect(session.recordSession).toBe(true);
289+
expect(isSessionRecording(session)).toBe(true);
289290
expect(scriptTargetPath(session.scriptPublication ?? NO_SCRIPT_PUBLICATION)).toBe(target);
290291

291292
const result = sessionStore.writeSessionLog(session);

‎src/daemon/__tests__/session-action-recorder.test.ts‎

Lines changed: 6 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -1,3 +1,4 @@
1+
import { isSessionRecording } from '../session-script-publication-capability.ts';
12
/**
23
* #1271 stage 2 (ADR 0012 amendment): `recordActionEntry`'s repair-segment
34
* default exclusion — the single daemon-side choke point every recording
@@ -267,8 +268,8 @@ test('whitespace-only fills collapse ambiguous recorder output and keys', () =>
267268

268269
test('#1533: the --save-script ingress does not re-arm an aborted authoring lifecycle', () => {
269270
const session = makeIosSession('s', {
270-
// What `abortAuthoringOnSecondOpen` leaves behind: terminal status, recording off.
271-
recordSession: false,
271+
// What `abortAuthoringOnSecondOpen` leaves behind: a terminal status, which
272+
// is by itself what stops the session recording.
272273
scriptPublication: authoringPublication('aborted'),
273274
});
274275

@@ -280,13 +281,12 @@ test('#1533: the --save-script ingress does not re-arm an aborted authoring life
280281
flags: { saveScript: true },
281282
});
282283

283-
expect(session.recordSession).toBe(false);
284+
expect(isSessionRecording(session)).toBe(false);
284285
expect(session.scriptPublication).toEqual(authoringPublication('aborted'));
285286
});
286287

287288
test('#1533: an aborted lifecycle cannot be retargeted by a later --save-script=<path> either', () => {
288289
const session = makeIosSession('s', {
289-
recordSession: false,
290290
scriptPublication: authoringPublication('aborted', { path: '/tmp/original.ad' }),
291291
});
292292

@@ -296,15 +296,14 @@ test('#1533: an aborted lifecycle cannot be retargeted by a later --save-script=
296296
flags: { saveScript: '/tmp/hijacked.ad', force: true },
297297
});
298298

299-
expect(session.recordSession).toBe(false);
299+
expect(isSessionRecording(session)).toBe(false);
300300
expect(session.scriptPublication).toEqual(
301301
authoringPublication('aborted', { path: '/tmp/original.ad' }),
302302
);
303303
});
304304

305305
test('#1533: an ARMED authoring lifecycle still takes the ingress (retarget + force unchanged)', () => {
306306
const session = makeIosSession('s', {
307-
recordSession: true,
308307
scriptPublication: authoringPublication('armed'),
309308
});
310309

@@ -314,7 +313,7 @@ test('#1533: an ARMED authoring lifecycle still takes the ingress (retarget + fo
314313
flags: { saveScript: '/tmp/out.ad', force: true },
315314
});
316315

317-
expect(session.recordSession).toBe(true);
316+
expect(isSessionRecording(session)).toBe(true);
318317
expect(session.scriptPublication).toEqual(
319318
authoringPublication('armed', { path: '/tmp/out.ad', force: true }),
320319
);

‎src/daemon/__tests__/session-script-publication-state.test.ts‎

Lines changed: 32 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,9 @@
11
import { expect, test } from 'vitest';
2-
import { armRepair, resolveScriptTarget } from '../session-script-publication-state.ts';
2+
import {
3+
armRepair,
4+
isRecordingPublication,
5+
resolveScriptTarget,
6+
} from '../session-script-publication-state.ts';
37

48
// The retention table for the per-target force model (#1258). The repair suites pin these
59
// transitively through healed-sibling paths; this pins the transition itself, so a regression
@@ -55,3 +59,30 @@ test('per-step repair re-arms never move the boundary or wipe the healed sibling
5559
const rearmed = armRepair(armed, { requested: { force: false }, boundary: 0 });
5660
expect(rearmed).toEqual(armed);
5761
});
62+
63+
// --- Recording is derived from the lifecycle, not stored beside it ---
64+
//
65+
// `SessionState.recordSession` used to hold this answer as a second source of truth, which is how
66+
// #1533 happened: a `--save-script` ingress re-armed the flag behind an ABORTED status. These pin
67+
// the whole table, because the predicate now decides both evidence capture and publication.
68+
69+
const target = { kind: 'default', force: false } as const;
70+
71+
test('a session with no publication lifecycle records nothing', () => {
72+
expect(isRecordingPublication({ kind: 'none' })).toBe(false);
73+
});
74+
75+
test('ordinary authoring records only while ARMED', () => {
76+
expect(isRecordingPublication({ kind: 'authoring', status: 'armed', target })).toBe(true);
77+
expect(isRecordingPublication({ kind: 'authoring', status: 'aborted', target })).toBe(false);
78+
expect(isRecordingPublication({ kind: 'authoring', status: 'published', target })).toBe(false);
79+
});
80+
81+
test('a repair transaction records for its whole lifetime, terminal statuses included', () => {
82+
// Deliberately exact, not merely safe: `armRepairStep` armed the old flag and neither
83+
// `abortRepair` nor `commitRepair` ever cleared it, so narrowing this would silently stop
84+
// evidence capture for a committed or aborted repair.
85+
for (const status of ['armed', 'complete', 'close-succeeded', 'committed', 'aborted'] as const) {
86+
expect(isRecordingPublication({ kind: 'repair', status, target, boundary: 0 })).toBe(true);
87+
}
88+
});

‎src/daemon/__tests__/session-store.test.ts‎

Lines changed: 0 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -773,7 +773,6 @@ test('BLOCKER 2: finalizeRepairTeardown of a COMPLETE transaction whose commit F
773773
const before = fs.readFileSync(healedPath, 'utf8');
774774

775775
const session = makeSession('default');
776-
session.recordSession = true;
777776
session.scriptPublication = repairPublication('complete', {
778777
boundary: 0,
779778
path: healedPath,
@@ -814,7 +813,6 @@ test('BLOCKER 3: finalizeRepairTeardown auto-commit records a terminal close, pr
814813
const healedPath = path.join(root, 'flow.healed.ad');
815814

816815
const session = makeSession('default');
817-
session.recordSession = true;
818816
session.scriptPublication = repairPublication('complete', { boundary: 0, path: healedPath });
819817
session.actions = [
820818
{ ts: 1, command: 'open', positionals: ['Demo'], flags: {} },

0 commit comments

Comments
 (0)