@atcx/contract 7.18.1 → 7.19.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +5 -5
- package/dist/{daemon-contract.d.ts → daemon-contract/daemon-contract.d.ts} +62 -62
- package/dist/{daemon-error-map.d.ts → daemon-contract/daemon-error-map.d.ts} +1 -1
- package/dist/{request-param-schemas.d.ts → daemon-contract/request-param-schemas.d.ts} +32 -32
- package/dist/{daemon-event.d.ts → daemon-events/daemon-event.d.ts} +16 -16
- package/dist/index.d.ts +51 -51
- package/dist/index.js +566 -566
- package/dist/{spawn-answer.d.ts → messages/spawn-answer-schema.d.ts} +4 -4
- package/dist/{session-descriptor.d.ts → sessions/session-descriptor.d.ts} +4 -4
- package/package.json +1 -1
- /package/dist/{agent-list.d.ts → config/agent-list.d.ts} +0 -0
- /package/dist/{config-file-schema.d.ts → config/config-file-schema.d.ts} +0 -0
- /package/dist/{contract-version.d.ts → daemon-contract/contract-version.d.ts} +0 -0
- /package/dist/{procedure-meta.d.ts → daemon-contract/procedure-meta.d.ts} +0 -0
- /package/dist/{events-page.d.ts → daemon-events/events-page-schema.d.ts} +0 -0
- /package/dist/{fleet-event.d.ts → daemon-events/fleet-event-schema.d.ts} +0 -0
- /package/dist/{max-events-cursor-bytes.d.ts → daemon-events/max-events-cursor-bytes.d.ts} +0 -0
- /package/dist/{transcript-row.d.ts → daemon-events/transcript-row.d.ts} +0 -0
- /package/dist/{gateway-paths.d.ts → gateway/gateway-paths.d.ts} +0 -0
- /package/dist/{gateway-registry-schema.d.ts → gateway/gateway-registry-schema.d.ts} +0 -0
- /package/dist/{max-registry-daemons.d.ts → gateway/max-registry-daemons.d.ts} +0 -0
- /package/dist/{check-daemon.d.ts → hello/check-daemon.d.ts} +0 -0
- /package/dist/{daemon-features.d.ts → hello/daemon-features.d.ts} +0 -0
- /package/dist/{hello-result.d.ts → hello/hello-result.d.ts} +0 -0
- /package/dist/{restart-result.d.ts → hello/restart-result.d.ts} +0 -0
- /package/dist/{agent-session-id.d.ts → ids/agent-session-id.d.ts} +0 -0
- /package/dist/{daemon-id.d.ts → ids/daemon-id.d.ts} +0 -0
- /package/dist/{message-id.d.ts → ids/message-id.d.ts} +0 -0
- /package/dist/{session-id.d.ts → ids/session-id.d.ts} +0 -0
- /package/dist/{to-agent-session-id.d.ts → ids/to-agent-session-id.d.ts} +0 -0
- /package/dist/{to-daemon-id.d.ts → ids/to-daemon-id.d.ts} +0 -0
- /package/dist/{to-message-id.d.ts → ids/to-message-id.d.ts} +0 -0
- /package/dist/{to-session-id.d.ts → ids/to-session-id.d.ts} +0 -0
- /package/dist/{answer-view.d.ts → messages/answer-view-schema.d.ts} +0 -0
- /package/dist/{menu-view.d.ts → messages/menu-view.d.ts} +0 -0
- /package/dist/{message-answer.d.ts → messages/message-answer-schema.d.ts} +0 -0
- /package/dist/{message-status.d.ts → messages/message-status-schema.d.ts} +0 -0
- /package/dist/{message-view.d.ts → messages/message-view-schema.d.ts} +0 -0
- /package/dist/{note-view.d.ts → messages/note-view-schema.d.ts} +0 -0
- /package/dist/{fleet-entry-view.d.ts → sessions/fleet-entry-view-schema.d.ts} +0 -0
- /package/dist/{grant-scope.d.ts → sessions/grant-scope.d.ts} +0 -0
- /package/dist/{published-record-schema.d.ts → sessions/published-record-schema.d.ts} +0 -0
- /package/dist/{published-record.d.ts → sessions/published-record.d.ts} +0 -0
- /package/dist/{session-lifecycle.d.ts → sessions/session-lifecycle.d.ts} +0 -0
- /package/dist/{session-workspace.d.ts → sessions/session-workspace.d.ts} +0 -0
- /package/dist/{source-candidate.d.ts → sources/source-candidate.d.ts} +0 -0
- /package/dist/{source-entry.d.ts → sources/source-entry.d.ts} +0 -0
- /package/dist/{source-interpretation.d.ts → sources/source-interpretation.d.ts} +0 -0
- /package/dist/{source-pick.d.ts → sources/source-pick.d.ts} +0 -0
- /package/dist/{spawn-option-spec.d.ts → sources/spawn-option-spec.d.ts} +0 -0
- /package/dist/{commit-id-pattern.d.ts → workspaces/commit-id-pattern.d.ts} +0 -0
- /package/dist/{git-probe-result.d.ts → workspaces/git-probe-result.d.ts} +0 -0
- /package/dist/{git-ref.d.ts → workspaces/git-ref.d.ts} +0 -0
- /package/dist/{workspace-cleanup.d.ts → workspaces/workspace-cleanup.d.ts} +0 -0
- /package/dist/{workspace-prune.d.ts → workspaces/workspace-prune.d.ts} +0 -0
package/dist/index.js
CHANGED
|
@@ -1,7 +1,7 @@
|
|
|
1
|
-
// packages/contract/src/agent-list.ts
|
|
1
|
+
// packages/contract/src/config/agent-list.ts
|
|
2
2
|
import { z as z3 } from "zod";
|
|
3
3
|
|
|
4
|
-
// packages/contract/src/source-entry.ts
|
|
4
|
+
// packages/contract/src/sources/source-entry.ts
|
|
5
5
|
import { z } from "zod";
|
|
6
6
|
var SOURCE_ENTRY_SCHEMA = z.object({
|
|
7
7
|
id: z.string(),
|
|
@@ -9,7 +9,7 @@ var SOURCE_ENTRY_SCHEMA = z.object({
|
|
|
9
9
|
kind: z.enum(["path", "git"])
|
|
10
10
|
});
|
|
11
11
|
|
|
12
|
-
// packages/contract/src/spawn-option-spec.ts
|
|
12
|
+
// packages/contract/src/sources/spawn-option-spec.ts
|
|
13
13
|
import { z as z2 } from "zod";
|
|
14
14
|
var SPAWN_OPTION_EXAMPLE_SCHEMA = z2.object({
|
|
15
15
|
value: z2.string(),
|
|
@@ -24,7 +24,7 @@ var SPAWN_OPTION_SPEC_SCHEMA = z2.object({
|
|
|
24
24
|
note: z2.string().nullable()
|
|
25
25
|
});
|
|
26
26
|
|
|
27
|
-
// packages/contract/src/agent-list.ts
|
|
27
|
+
// packages/contract/src/config/agent-list.ts
|
|
28
28
|
var SPAWN_OPTION_ENTRY_SCHEMA = SPAWN_OPTION_SPEC_SCHEMA.extend({ available: z3.boolean() });
|
|
29
29
|
var AGENT_ENTRY_SCHEMA = z3.object({
|
|
30
30
|
id: z3.string(),
|
|
@@ -98,7 +98,7 @@ var AGENT_LIST_SCHEMA = z3.object({
|
|
|
98
98
|
targetErrors: z3.array(TARGET_CONFIG_ERROR_SCHEMA).readonly(),
|
|
99
99
|
sources: z3.array(SOURCE_ENTRY_SCHEMA).readonly()
|
|
100
100
|
});
|
|
101
|
-
// packages/contract/src/answer-view.ts
|
|
101
|
+
// packages/contract/src/messages/answer-view-schema.ts
|
|
102
102
|
import { z as z4 } from "zod";
|
|
103
103
|
var ANSWER_VIEW_SCHEMA = z4.object({
|
|
104
104
|
answer: z4.string(),
|
|
@@ -109,10 +109,10 @@ var ANSWER_VIEW_SCHEMA = z4.object({
|
|
|
109
109
|
text: z4.string(),
|
|
110
110
|
complete: z4.boolean()
|
|
111
111
|
});
|
|
112
|
-
// packages/contract/src/contract-version.ts
|
|
113
|
-
var CONTRACT_VERSION = "7.
|
|
112
|
+
// packages/contract/src/daemon-contract/contract-version.ts
|
|
113
|
+
var CONTRACT_VERSION = "7.19.0";
|
|
114
114
|
|
|
115
|
-
// packages/contract/src/daemon-features.ts
|
|
115
|
+
// packages/contract/src/hello/daemon-features.ts
|
|
116
116
|
var DAEMON_FEATURES = [
|
|
117
117
|
"events.read.from-start",
|
|
118
118
|
"daemon.hello.viewer",
|
|
@@ -120,7 +120,7 @@ var DAEMON_FEATURES = [
|
|
|
120
120
|
"session.host"
|
|
121
121
|
];
|
|
122
122
|
|
|
123
|
-
// packages/contract/src/check-daemon.ts
|
|
123
|
+
// packages/contract/src/hello/check-daemon.ts
|
|
124
124
|
function checkDaemon(hello, contractVersion = CONTRACT_VERSION) {
|
|
125
125
|
const daemonMajor = parseMajor(hello.daemon.replace(/^atc\//u, ""));
|
|
126
126
|
const contractMajor = parseMajor(contractVersion);
|
|
@@ -148,9 +148,9 @@ function parseMajor(version) {
|
|
|
148
148
|
const major = /^(?<major>\d+)\.\d+\.\d+/u.exec(version)?.groups?.["major"];
|
|
149
149
|
return major === undefined ? null : Number(major);
|
|
150
150
|
}
|
|
151
|
-
// packages/contract/src/commit-id-pattern.ts
|
|
151
|
+
// packages/contract/src/workspaces/commit-id-pattern.ts
|
|
152
152
|
var COMMIT_ID_PATTERN = /^(?:[\da-f]{40}|[\da-f]{64})$/u;
|
|
153
|
-
// packages/contract/src/config-file-schema.ts
|
|
153
|
+
// packages/contract/src/config/config-file-schema.ts
|
|
154
154
|
import { z as z7 } from "zod";
|
|
155
155
|
|
|
156
156
|
// packages/contract/src/schema/build-optional-boolean.ts
|
|
@@ -165,7 +165,7 @@ function buildOptionalString() {
|
|
|
165
165
|
return z6.preprocess((value) => typeof value === "string" ? value : undefined, z6.string().optional());
|
|
166
166
|
}
|
|
167
167
|
|
|
168
|
-
// packages/contract/src/config-file-schema.ts
|
|
168
|
+
// packages/contract/src/config/config-file-schema.ts
|
|
169
169
|
var CONFIG_FILE_SCHEMA = z7.object({
|
|
170
170
|
agents: z7.unknown().optional(),
|
|
171
171
|
sources: z7.unknown().optional(),
|
|
@@ -180,12 +180,468 @@ var CONFIG_FILE_SCHEMA = z7.object({
|
|
|
180
180
|
daemons: z7.unknown().optional(),
|
|
181
181
|
restoreFleetOnRestart: buildOptionalBoolean()
|
|
182
182
|
});
|
|
183
|
-
// packages/contract/src/daemon-contract.ts
|
|
183
|
+
// packages/contract/src/daemon-contract/daemon-contract.ts
|
|
184
184
|
import { eventIterator, oc } from "@orpc/contract";
|
|
185
185
|
import { z as z39 } from "zod";
|
|
186
186
|
|
|
187
|
-
// packages/contract/src/daemon-
|
|
187
|
+
// packages/contract/src/daemon-events/daemon-event.ts
|
|
188
|
+
import { z as z17 } from "zod";
|
|
189
|
+
|
|
190
|
+
// packages/contract/src/hello/restart-result.ts
|
|
188
191
|
import { z as z8 } from "zod";
|
|
192
|
+
var RESTART_FAILED_ROW_SCHEMA = z8.object({
|
|
193
|
+
name: z8.string(),
|
|
194
|
+
id: z8.string(),
|
|
195
|
+
reason: z8.string()
|
|
196
|
+
});
|
|
197
|
+
var RESTART_INTERRUPTED_ROW_SCHEMA = z8.object({ name: z8.string(), id: z8.string() });
|
|
198
|
+
var RESTART_RESULT_SCHEMA = z8.object({
|
|
199
|
+
runID: z8.string(),
|
|
200
|
+
code: z8.number().int(),
|
|
201
|
+
pid: z8.number().int().nullable(),
|
|
202
|
+
build: z8.string().nullable(),
|
|
203
|
+
listenPort: z8.number().int().nullable(),
|
|
204
|
+
restored: z8.number().int(),
|
|
205
|
+
total: z8.number().int(),
|
|
206
|
+
failed: z8.array(RESTART_FAILED_ROW_SCHEMA).readonly(),
|
|
207
|
+
interrupted: z8.array(RESTART_INTERRUPTED_ROW_SCHEMA).readonly(),
|
|
208
|
+
error: z8.string().nullable()
|
|
209
|
+
});
|
|
210
|
+
|
|
211
|
+
// packages/contract/src/light/message-sender.ts
|
|
212
|
+
import { z as z9 } from "zod";
|
|
213
|
+
var MESSAGE_SENDER_SCHEMA = z9.discriminatedUnion("kind", [
|
|
214
|
+
z9.object({ kind: z9.literal("connector"), client: z9.string(), name: z9.string() }),
|
|
215
|
+
z9.object({ kind: z9.literal("session"), session: z9.string(), name: z9.string() }),
|
|
216
|
+
z9.object({ kind: z9.literal("local"), name: z9.string() }),
|
|
217
|
+
z9.object({ kind: z9.literal("owner"), name: z9.string() })
|
|
218
|
+
]);
|
|
219
|
+
|
|
220
|
+
// packages/contract/src/messages/message-status-schema.ts
|
|
221
|
+
import { z as z10 } from "zod";
|
|
222
|
+
var MESSAGE_STATUS_SCHEMA = z10.enum(["queued", "delivered", "answered", "unanswered"]);
|
|
223
|
+
|
|
224
|
+
// packages/contract/src/sessions/session-descriptor.ts
|
|
225
|
+
import { z as z16 } from "zod";
|
|
226
|
+
|
|
227
|
+
// packages/contract/src/ids/to-agent-session-id.ts
|
|
228
|
+
import { z as z11 } from "zod";
|
|
229
|
+
var AGENT_SESSION_ID_SCHEMA = z11.string().brand();
|
|
230
|
+
function toAgentSessionID(id) {
|
|
231
|
+
return AGENT_SESSION_ID_SCHEMA.parse(id);
|
|
232
|
+
}
|
|
233
|
+
|
|
234
|
+
// packages/contract/src/ids/to-daemon-id.ts
|
|
235
|
+
import { z as z12 } from "zod";
|
|
236
|
+
var DAEMON_ID_SCHEMA = z12.string().brand();
|
|
237
|
+
function toDaemonID(id) {
|
|
238
|
+
return DAEMON_ID_SCHEMA.parse(id);
|
|
239
|
+
}
|
|
240
|
+
|
|
241
|
+
// packages/contract/src/ids/to-session-id.ts
|
|
242
|
+
import { z as z13 } from "zod";
|
|
243
|
+
var SESSION_ID_SCHEMA = z13.string().brand();
|
|
244
|
+
function toSessionID(id) {
|
|
245
|
+
return SESSION_ID_SCHEMA.parse(id);
|
|
246
|
+
}
|
|
247
|
+
|
|
248
|
+
// packages/contract/src/sessions/session-lifecycle.ts
|
|
249
|
+
import { z as z14 } from "zod";
|
|
250
|
+
var SESSION_LIFECYCLE_SCHEMA = z14.object({
|
|
251
|
+
desired: z14.enum(["run", "sleep", "stop"]),
|
|
252
|
+
vm: z14.enum(["none", "awake", "asleep", "unknown"]),
|
|
253
|
+
harness: z14.enum(["running", "suspended", "exited"]),
|
|
254
|
+
attachment: z14.enum(["local", "attached", "reattaching", "detached"])
|
|
255
|
+
});
|
|
256
|
+
|
|
257
|
+
// packages/contract/src/sessions/session-workspace.ts
|
|
258
|
+
import { z as z15 } from "zod";
|
|
259
|
+
var SESSION_WORKSPACE_SCHEMA = z15.object({
|
|
260
|
+
repoURL: z15.string(),
|
|
261
|
+
sha: z15.string(),
|
|
262
|
+
ref: z15.string().optional(),
|
|
263
|
+
materializedAt: z15.number()
|
|
264
|
+
});
|
|
265
|
+
|
|
266
|
+
// packages/contract/src/sessions/session-descriptor.ts
|
|
267
|
+
var SESSION_HOST_SCHEMA = z16.object({
|
|
268
|
+
name: z16.string(),
|
|
269
|
+
id: z16.string().optional(),
|
|
270
|
+
issuer: z16.string().optional()
|
|
271
|
+
});
|
|
272
|
+
var SESSION_DESCRIPTOR_SCHEMA = z16.object({
|
|
273
|
+
id: z16.string().transform((id) => toSessionID(id)),
|
|
274
|
+
name: z16.string(),
|
|
275
|
+
cwd: z16.string(),
|
|
276
|
+
state: z16.enum(["running", "needs_you", "done", "exited"]),
|
|
277
|
+
unread: z16.boolean(),
|
|
278
|
+
lastMsg: z16.string(),
|
|
279
|
+
lastDetail: z16.string().optional(),
|
|
280
|
+
restoreRefusal: z16.string().optional(),
|
|
281
|
+
agentSessionID: z16.string().transform((id) => toAgentSessionID(id)).optional(),
|
|
282
|
+
agent: z16.string(),
|
|
283
|
+
pinned: z16.boolean(),
|
|
284
|
+
lastAttachedAt: z16.number(),
|
|
285
|
+
repoRoot: z16.string(),
|
|
286
|
+
namedBy: z16.enum(["user", "auto", "agent"]),
|
|
287
|
+
createdAt: z16.number(),
|
|
288
|
+
kind: z16.enum(["pty", "headless"]),
|
|
289
|
+
alive: z16.boolean(),
|
|
290
|
+
canEject: z16.boolean(),
|
|
291
|
+
parent: z16.string().transform((id) => toSessionID(id)).optional(),
|
|
292
|
+
locator: z16.object({
|
|
293
|
+
daemonID: z16.string().transform((id) => toDaemonID(id)),
|
|
294
|
+
targetID: z16.string()
|
|
295
|
+
}),
|
|
296
|
+
workspace: SESSION_WORKSPACE_SCHEMA.optional(),
|
|
297
|
+
lifecycle: SESSION_LIFECYCLE_SCHEMA,
|
|
298
|
+
model: z16.string().optional(),
|
|
299
|
+
pluginDirs: z16.array(z16.string()).readonly().optional(),
|
|
300
|
+
host: SESSION_HOST_SCHEMA.optional()
|
|
301
|
+
});
|
|
302
|
+
|
|
303
|
+
// packages/contract/src/daemon-events/daemon-event.ts
|
|
304
|
+
var SESSION_EVENT = z17.object({ session: SESSION_DESCRIPTOR_SCHEMA });
|
|
305
|
+
var DAEMON_EVENT_SCHEMA = z17.discriminatedUnion("ev", [
|
|
306
|
+
SESSION_EVENT.extend({ ev: z17.literal("SessionAdded") }),
|
|
307
|
+
SESSION_EVENT.extend({ ev: z17.literal("SessionState") }),
|
|
308
|
+
SESSION_EVENT.extend({ ev: z17.literal("SessionAttached") }),
|
|
309
|
+
SESSION_EVENT.extend({ ev: z17.literal("SessionDetached") }),
|
|
310
|
+
z17.object({
|
|
311
|
+
ev: z17.literal("SessionRenamed"),
|
|
312
|
+
sessionID: z17.string(),
|
|
313
|
+
name: z17.string(),
|
|
314
|
+
namedBy: z17.enum(["user", "auto", "agent"])
|
|
315
|
+
}),
|
|
316
|
+
z17.object({ ev: z17.literal("SessionRemoved"), sessionID: z17.string() }),
|
|
317
|
+
z17.object({
|
|
318
|
+
ev: z17.literal("SessionResized"),
|
|
319
|
+
sessionID: z17.string(),
|
|
320
|
+
cols: z17.number(),
|
|
321
|
+
rows: z17.number()
|
|
322
|
+
}),
|
|
323
|
+
z17.object({
|
|
324
|
+
ev: z17.literal("SessionOutput"),
|
|
325
|
+
sessionID: z17.string(),
|
|
326
|
+
seq: z17.number(),
|
|
327
|
+
data: z17.string()
|
|
328
|
+
}),
|
|
329
|
+
z17.object({ ev: z17.literal("SessionDesync"), sessionID: z17.string(), dropped: z17.number() }),
|
|
330
|
+
z17.object({
|
|
331
|
+
ev: z17.literal("PermissionRequested"),
|
|
332
|
+
request: z17.string(),
|
|
333
|
+
sessionID: z17.string(),
|
|
334
|
+
message: z17.string(),
|
|
335
|
+
respondable: z17.boolean()
|
|
336
|
+
}),
|
|
337
|
+
z17.object({ ev: z17.literal("PermissionResolved"), request: z17.string(), decision: z17.string() }),
|
|
338
|
+
z17.object({
|
|
339
|
+
ev: z17.literal("SessionMessage"),
|
|
340
|
+
sessionID: z17.string(),
|
|
341
|
+
message: z17.string(),
|
|
342
|
+
status: MESSAGE_STATUS_SCHEMA,
|
|
343
|
+
from: z17.string(),
|
|
344
|
+
sender: MESSAGE_SENDER_SCHEMA.optional(),
|
|
345
|
+
textPreview: z17.string(),
|
|
346
|
+
sentAt: z17.number(),
|
|
347
|
+
deliveredAt: z17.number().optional(),
|
|
348
|
+
answeredAt: z17.number().optional(),
|
|
349
|
+
answerPreview: z17.string().optional(),
|
|
350
|
+
unansweredAt: z17.number().optional(),
|
|
351
|
+
unansweredReason: z17.string().optional()
|
|
352
|
+
}),
|
|
353
|
+
z17.object({
|
|
354
|
+
ev: z17.literal("SessionNote"),
|
|
355
|
+
sessionID: z17.string(),
|
|
356
|
+
kind: z17.string(),
|
|
357
|
+
text: z17.string(),
|
|
358
|
+
sentAt: z17.number()
|
|
359
|
+
}),
|
|
360
|
+
z17.object({
|
|
361
|
+
ev: z17.literal("InboxMessage"),
|
|
362
|
+
sessionID: z17.string(),
|
|
363
|
+
message: z17.string(),
|
|
364
|
+
from: z17.string(),
|
|
365
|
+
sender: MESSAGE_SENDER_SCHEMA.optional(),
|
|
366
|
+
text: z17.string(),
|
|
367
|
+
sentAt: z17.number()
|
|
368
|
+
}),
|
|
369
|
+
z17.object({
|
|
370
|
+
ev: z17.literal("InboxNotice"),
|
|
371
|
+
sessionID: z17.string(),
|
|
372
|
+
message: z17.string(),
|
|
373
|
+
from: z17.string(),
|
|
374
|
+
status: z17.enum(["answered", "unanswered"]),
|
|
375
|
+
answer: z17.string().optional(),
|
|
376
|
+
reason: z17.string().optional(),
|
|
377
|
+
at: z17.number()
|
|
378
|
+
}),
|
|
379
|
+
z17.object({
|
|
380
|
+
ev: z17.literal("InboxClosed"),
|
|
381
|
+
sessionID: z17.string(),
|
|
382
|
+
reason: z17.enum(["replaced", "removed"])
|
|
383
|
+
}),
|
|
384
|
+
z17.object({ ev: z17.literal("DaemonRestarted"), result: RESTART_RESULT_SCHEMA })
|
|
385
|
+
]);
|
|
386
|
+
|
|
387
|
+
// packages/contract/src/daemon-events/events-page-schema.ts
|
|
388
|
+
import { z as z19 } from "zod";
|
|
389
|
+
|
|
390
|
+
// packages/contract/src/daemon-events/fleet-event-schema.ts
|
|
391
|
+
import { z as z18 } from "zod";
|
|
392
|
+
var FLEET_EVENT_SCHEMA = z18.object({
|
|
393
|
+
cursor: z18.string(),
|
|
394
|
+
at: z18.number(),
|
|
395
|
+
session: z18.string(),
|
|
396
|
+
name: z18.string().nullable(),
|
|
397
|
+
kind: z18.string(),
|
|
398
|
+
detail: z18.string().nullable(),
|
|
399
|
+
message: z18.string().optional(),
|
|
400
|
+
label: z18.string().optional(),
|
|
401
|
+
result: RESTART_RESULT_SCHEMA.optional(),
|
|
402
|
+
origin: z18.object({ daemon: z18.string(), incarnation: z18.string(), cursor: z18.string() }).optional()
|
|
403
|
+
});
|
|
404
|
+
|
|
405
|
+
// packages/contract/src/daemon-events/events-page-schema.ts
|
|
406
|
+
var EVENTS_PAGE_SCHEMA = z19.object({
|
|
407
|
+
events: z19.array(FLEET_EVENT_SCHEMA).readonly(),
|
|
408
|
+
cursor: z19.string(),
|
|
409
|
+
more: z19.boolean()
|
|
410
|
+
});
|
|
411
|
+
|
|
412
|
+
// packages/contract/src/daemon-events/transcript-row.ts
|
|
413
|
+
import { z as z20 } from "zod";
|
|
414
|
+
var TRANSCRIPT_TOOL_SCHEMA = z20.object({ name: z20.string(), input: z20.string() });
|
|
415
|
+
var TRANSCRIPT_ROW_SCHEMA = z20.object({
|
|
416
|
+
role: z20.enum(["user", "assistant"]),
|
|
417
|
+
text: z20.string(),
|
|
418
|
+
tools: z20.array(TRANSCRIPT_TOOL_SCHEMA).readonly(),
|
|
419
|
+
at: z20.number().nullable()
|
|
420
|
+
});
|
|
421
|
+
|
|
422
|
+
// packages/contract/src/hello/hello-result.ts
|
|
423
|
+
import { z as z21 } from "zod";
|
|
424
|
+
var HELLO_RESULT_SCHEMA = z21.object({
|
|
425
|
+
daemon: z21.string(),
|
|
426
|
+
daemonID: z21.string(),
|
|
427
|
+
limits: z21.object({ maxLine: z21.number(), maxChunk: z21.number() }),
|
|
428
|
+
idempotency: z21.object({ completedRetentionMs: z21.number() }),
|
|
429
|
+
lastUsedAgent: z21.string(),
|
|
430
|
+
peerSession: z21.string().nullable(),
|
|
431
|
+
features: z21.array(z21.string()).readonly().default([])
|
|
432
|
+
});
|
|
433
|
+
|
|
434
|
+
// packages/contract/src/messages/menu-view.ts
|
|
435
|
+
import { z as z22 } from "zod";
|
|
436
|
+
var MENU_VIEW_SCHEMA = z22.object({
|
|
437
|
+
text: z22.string(),
|
|
438
|
+
options: z22.array(buildMenuOptionSchema()).readonly(),
|
|
439
|
+
menuToken: z22.string()
|
|
440
|
+
});
|
|
441
|
+
function buildMenuOptionSchema() {
|
|
442
|
+
return z22.object({
|
|
443
|
+
option: z22.number(),
|
|
444
|
+
label: z22.string(),
|
|
445
|
+
checked: z22.boolean().nullable(),
|
|
446
|
+
highlighted: z22.boolean()
|
|
447
|
+
});
|
|
448
|
+
}
|
|
449
|
+
|
|
450
|
+
// packages/contract/src/messages/message-answer-schema.ts
|
|
451
|
+
import { z as z23 } from "zod";
|
|
452
|
+
var MESSAGE_ANSWER_SCHEMA = z23.object({
|
|
453
|
+
message: z23.string(),
|
|
454
|
+
status: MESSAGE_STATUS_SCHEMA
|
|
455
|
+
});
|
|
456
|
+
|
|
457
|
+
// packages/contract/src/messages/message-view-schema.ts
|
|
458
|
+
import { z as z24 } from "zod";
|
|
459
|
+
var MESSAGE_VIEW_SCHEMA = z24.object({
|
|
460
|
+
message: z24.string(),
|
|
461
|
+
session: z24.string(),
|
|
462
|
+
from: z24.string(),
|
|
463
|
+
sender: MESSAGE_SENDER_SCHEMA.optional(),
|
|
464
|
+
text: z24.string(),
|
|
465
|
+
status: MESSAGE_STATUS_SCHEMA,
|
|
466
|
+
sentAt: z24.number(),
|
|
467
|
+
deliveredAt: z24.number().optional(),
|
|
468
|
+
answeredAt: z24.number().optional(),
|
|
469
|
+
answer: z24.string().optional(),
|
|
470
|
+
unansweredAt: z24.number().optional(),
|
|
471
|
+
unansweredReason: z24.string().optional(),
|
|
472
|
+
turn: z24.string().nullable(),
|
|
473
|
+
answeredWith: z24.array(z24.string()).readonly()
|
|
474
|
+
});
|
|
475
|
+
|
|
476
|
+
// packages/contract/src/messages/note-view-schema.ts
|
|
477
|
+
import { z as z25 } from "zod";
|
|
478
|
+
var NOTE_VIEW_SCHEMA = z25.object({
|
|
479
|
+
note: z25.string(),
|
|
480
|
+
at: z25.number(),
|
|
481
|
+
session: z25.string(),
|
|
482
|
+
name: z25.string().nullable(),
|
|
483
|
+
label: z25.string(),
|
|
484
|
+
text: z25.string(),
|
|
485
|
+
complete: z25.boolean()
|
|
486
|
+
});
|
|
487
|
+
|
|
488
|
+
// packages/contract/src/messages/spawn-answer-schema.ts
|
|
489
|
+
import { z as z26 } from "zod";
|
|
490
|
+
var SPAWN_ANSWER_SCHEMA = z26.object({
|
|
491
|
+
session: SESSION_DESCRIPTOR_SCHEMA,
|
|
492
|
+
warnings: z26.array(z26.string()).readonly().optional()
|
|
493
|
+
});
|
|
494
|
+
|
|
495
|
+
// packages/contract/src/sessions/fleet-entry-view-schema.ts
|
|
496
|
+
import { z as z27 } from "zod";
|
|
497
|
+
var FLEET_ENTRY_VIEW_SCHEMA = z27.object({
|
|
498
|
+
sessionID: z27.string(),
|
|
499
|
+
name: z27.string(),
|
|
500
|
+
cwd: z27.string(),
|
|
501
|
+
agentSessionID: z27.string().optional(),
|
|
502
|
+
agent: z27.string(),
|
|
503
|
+
pinned: z27.boolean().optional(),
|
|
504
|
+
lastAttachedAt: z27.number().optional(),
|
|
505
|
+
exited: z27.boolean().optional(),
|
|
506
|
+
parent: z27.string().optional(),
|
|
507
|
+
prompt: z27.string().optional(),
|
|
508
|
+
result: z27.string().optional(),
|
|
509
|
+
transcriptPath: z27.string().optional(),
|
|
510
|
+
model: z27.string().optional(),
|
|
511
|
+
effort: z27.string().optional(),
|
|
512
|
+
pluginDirs: z27.array(z27.string()).readonly().optional(),
|
|
513
|
+
target: z27.string().optional(),
|
|
514
|
+
targetIdentity: z27.string().optional(),
|
|
515
|
+
workspace: SESSION_WORKSPACE_SCHEMA.optional(),
|
|
516
|
+
withheldEnv: z27.array(z27.string()).readonly().optional(),
|
|
517
|
+
desired: z27.enum(["sleep", "stop"]).optional(),
|
|
518
|
+
hostKey: z27.string().optional()
|
|
519
|
+
});
|
|
520
|
+
|
|
521
|
+
// packages/contract/src/sessions/published-record-schema.ts
|
|
522
|
+
import { z as z28 } from "zod";
|
|
523
|
+
var WORKSPACE_SCOPE_SCHEMA = z28.object({
|
|
524
|
+
path: z28.string(),
|
|
525
|
+
branch: z28.string().nullable(),
|
|
526
|
+
repoURL: z28.string().nullable(),
|
|
527
|
+
sha: z28.string().nullable()
|
|
528
|
+
});
|
|
529
|
+
var WORKTREE_SCOPE_SCHEMA = z28.object({ path: z28.string(), branch: z28.string().nullable() });
|
|
530
|
+
var BRANCH_SCOPE_SCHEMA = z28.object({ name: z28.string(), repo: z28.string() });
|
|
531
|
+
var PULL_REQUEST_SCOPE_SCHEMA = z28.object({
|
|
532
|
+
repo: z28.string(),
|
|
533
|
+
number: z28.number(),
|
|
534
|
+
url: z28.string(),
|
|
535
|
+
branch: z28.string()
|
|
536
|
+
});
|
|
537
|
+
var SCOPE_SCHEMA = z28.object({
|
|
538
|
+
workspace: WORKSPACE_SCOPE_SCHEMA,
|
|
539
|
+
worktrees: z28.array(WORKTREE_SCOPE_SCHEMA),
|
|
540
|
+
branches: z28.array(BRANCH_SCOPE_SCHEMA),
|
|
541
|
+
pullRequests: z28.array(PULL_REQUEST_SCOPE_SCHEMA)
|
|
542
|
+
});
|
|
543
|
+
var PUBLISHED_RECORD_SCHEMA = z28.object({
|
|
544
|
+
format: z28.literal("atc.session-record"),
|
|
545
|
+
version: z28.literal(1),
|
|
546
|
+
session: z28.string(),
|
|
547
|
+
daemonID: z28.string(),
|
|
548
|
+
target: z28.string(),
|
|
549
|
+
revision: z28.number().int().min(1),
|
|
550
|
+
updatedAt: z28.string(),
|
|
551
|
+
name: z28.string().nullable(),
|
|
552
|
+
transcriptPath: z28.string().nullable(),
|
|
553
|
+
spawner: z28.string().nullable(),
|
|
554
|
+
scratch: z28.string().nullable(),
|
|
555
|
+
scope: SCOPE_SCHEMA
|
|
556
|
+
});
|
|
557
|
+
|
|
558
|
+
// packages/contract/src/sources/source-candidate.ts
|
|
559
|
+
import { z as z30 } from "zod";
|
|
560
|
+
|
|
561
|
+
// packages/contract/src/sources/source-pick.ts
|
|
562
|
+
import { z as z29 } from "zod";
|
|
563
|
+
var SOURCE_PICK_SCHEMA = z29.discriminatedUnion("kind", [
|
|
564
|
+
z29.object({ kind: z29.literal("path"), directory: z29.string() }),
|
|
565
|
+
z29.object({ kind: z29.literal("git"), url: z29.string() })
|
|
566
|
+
]);
|
|
567
|
+
|
|
568
|
+
// packages/contract/src/sources/source-candidate.ts
|
|
569
|
+
var SOURCE_CANDIDATE_SCHEMA = z30.object({
|
|
570
|
+
label: z30.string(),
|
|
571
|
+
detail: z30.string().optional(),
|
|
572
|
+
pick: SOURCE_PICK_SCHEMA
|
|
573
|
+
});
|
|
574
|
+
|
|
575
|
+
// packages/contract/src/sources/source-interpretation.ts
|
|
576
|
+
import { z as z31 } from "zod";
|
|
577
|
+
var SOURCE_INTERPRETATION_SCHEMA = z31.union([
|
|
578
|
+
z31.object({ kind: z31.literal("browse"), scope: z31.string() }),
|
|
579
|
+
SOURCE_PICK_SCHEMA,
|
|
580
|
+
z31.object({ kind: z31.literal("none") })
|
|
581
|
+
]);
|
|
582
|
+
|
|
583
|
+
// packages/contract/src/workspaces/git-probe-result.ts
|
|
584
|
+
import { z as z33 } from "zod";
|
|
585
|
+
|
|
586
|
+
// packages/contract/src/workspaces/git-ref.ts
|
|
587
|
+
import { z as z32 } from "zod";
|
|
588
|
+
var GIT_REF_SCHEMA = z32.object({
|
|
589
|
+
name: z32.string(),
|
|
590
|
+
kind: z32.enum(["branch", "tag"]),
|
|
591
|
+
sha: z32.string()
|
|
592
|
+
});
|
|
593
|
+
|
|
594
|
+
// packages/contract/src/workspaces/git-probe-result.ts
|
|
595
|
+
var GIT_PROBE_RESULT_SCHEMA = z33.object({
|
|
596
|
+
url: z33.string(),
|
|
597
|
+
head: z33.string().nullable(),
|
|
598
|
+
refs: z33.array(GIT_REF_SCHEMA).readonly(),
|
|
599
|
+
resolved: z33.object({ sha: z33.string(), branch: z33.string().nullable() }).nullable()
|
|
600
|
+
});
|
|
601
|
+
|
|
602
|
+
// packages/contract/src/workspaces/workspace-cleanup.ts
|
|
603
|
+
import { z as z34 } from "zod";
|
|
604
|
+
var STRINGS = z34.array(z34.string()).readonly();
|
|
605
|
+
var WORKSPACE_CLEANUP_SCHEMA = z34.discriminatedUnion("outcome", [
|
|
606
|
+
z34.object({ outcome: z34.literal("removed"), path: z34.string(), found: STRINGS }),
|
|
607
|
+
z34.object({ outcome: z34.literal("kept"), path: z34.string(), reasons: STRINGS }),
|
|
608
|
+
z34.object({ outcome: z34.literal("none") })
|
|
609
|
+
]);
|
|
610
|
+
|
|
611
|
+
// packages/contract/src/workspaces/workspace-prune.ts
|
|
612
|
+
import { z as z35 } from "zod";
|
|
613
|
+
var STRINGS2 = z35.array(z35.string()).readonly();
|
|
614
|
+
var KIND = z35.enum(["workspace", "state"]);
|
|
615
|
+
var BYTES = z35.number().int().nonnegative().nullable();
|
|
616
|
+
var PRUNE_FOLDER_SCHEMA = z35.discriminatedUnion("verdict", [
|
|
617
|
+
z35.object({
|
|
618
|
+
verdict: z35.literal("remove"),
|
|
619
|
+
kind: KIND,
|
|
620
|
+
path: z35.string(),
|
|
621
|
+
bytes: BYTES,
|
|
622
|
+
found: STRINGS2
|
|
623
|
+
}),
|
|
624
|
+
z35.object({
|
|
625
|
+
verdict: z35.literal("keep"),
|
|
626
|
+
kind: KIND,
|
|
627
|
+
path: z35.string(),
|
|
628
|
+
bytes: BYTES,
|
|
629
|
+
reasons: STRINGS2
|
|
630
|
+
}),
|
|
631
|
+
z35.object({
|
|
632
|
+
verdict: z35.literal("skip"),
|
|
633
|
+
kind: z35.literal("workspace"),
|
|
634
|
+
path: z35.string(),
|
|
635
|
+
reason: z35.string()
|
|
636
|
+
})
|
|
637
|
+
]);
|
|
638
|
+
var WORKSPACE_PRUNE_SCHEMA = z35.object({
|
|
639
|
+
dryRun: z35.boolean(),
|
|
640
|
+
folders: z35.array(PRUNE_FOLDER_SCHEMA).readonly()
|
|
641
|
+
});
|
|
642
|
+
|
|
643
|
+
// packages/contract/src/daemon-contract/daemon-error-map.ts
|
|
644
|
+
import { z as z36 } from "zod";
|
|
189
645
|
|
|
190
646
|
// packages/contract/src/light/error-codes.ts
|
|
191
647
|
var ERROR_CODES = [
|
|
@@ -263,8 +719,8 @@ var ERROR_CODES = [
|
|
|
263
719
|
"internal"
|
|
264
720
|
];
|
|
265
721
|
|
|
266
|
-
// packages/contract/src/daemon-error-map.ts
|
|
267
|
-
var ERROR_DATA_SCHEMA =
|
|
722
|
+
// packages/contract/src/daemon-contract/daemon-error-map.ts
|
|
723
|
+
var ERROR_DATA_SCHEMA = z36.record(z36.string(), z36.unknown()).optional();
|
|
268
724
|
var DAEMON_ERROR_MAP = buildErrorMap();
|
|
269
725
|
function buildErrorMap() {
|
|
270
726
|
const map = {};
|
|
@@ -280,414 +736,41 @@ function hasEveryCode(map) {
|
|
|
280
736
|
return ERROR_CODES.every((code) => Object.hasOwn(map, code));
|
|
281
737
|
}
|
|
282
738
|
|
|
283
|
-
// packages/contract/src/daemon-
|
|
284
|
-
import { z as
|
|
285
|
-
|
|
286
|
-
// packages/contract/src/light/message-sender.ts
|
|
287
|
-
import { z as z9 } from "zod";
|
|
288
|
-
var MESSAGE_SENDER_SCHEMA = z9.discriminatedUnion("kind", [
|
|
289
|
-
z9.object({ kind: z9.literal("connector"), client: z9.string(), name: z9.string() }),
|
|
290
|
-
z9.object({ kind: z9.literal("session"), session: z9.string(), name: z9.string() }),
|
|
291
|
-
z9.object({ kind: z9.literal("local"), name: z9.string() }),
|
|
292
|
-
z9.object({ kind: z9.literal("owner"), name: z9.string() })
|
|
293
|
-
]);
|
|
294
|
-
|
|
295
|
-
// packages/contract/src/message-status.ts
|
|
296
|
-
import { z as z10 } from "zod";
|
|
297
|
-
var MESSAGE_STATUS_SCHEMA = z10.enum(["queued", "delivered", "answered", "unanswered"]);
|
|
298
|
-
|
|
299
|
-
// packages/contract/src/restart-result.ts
|
|
300
|
-
import { z as z11 } from "zod";
|
|
301
|
-
var RESTART_FAILED_ROW_SCHEMA = z11.object({
|
|
302
|
-
name: z11.string(),
|
|
303
|
-
id: z11.string(),
|
|
304
|
-
reason: z11.string()
|
|
305
|
-
});
|
|
306
|
-
var RESTART_INTERRUPTED_ROW_SCHEMA = z11.object({ name: z11.string(), id: z11.string() });
|
|
307
|
-
var RESTART_RESULT_SCHEMA = z11.object({
|
|
308
|
-
runID: z11.string(),
|
|
309
|
-
code: z11.number().int(),
|
|
310
|
-
pid: z11.number().int().nullable(),
|
|
311
|
-
build: z11.string().nullable(),
|
|
312
|
-
listenPort: z11.number().int().nullable(),
|
|
313
|
-
restored: z11.number().int(),
|
|
314
|
-
total: z11.number().int(),
|
|
315
|
-
failed: z11.array(RESTART_FAILED_ROW_SCHEMA).readonly(),
|
|
316
|
-
interrupted: z11.array(RESTART_INTERRUPTED_ROW_SCHEMA).readonly(),
|
|
317
|
-
error: z11.string().nullable()
|
|
318
|
-
});
|
|
319
|
-
|
|
320
|
-
// packages/contract/src/session-descriptor.ts
|
|
321
|
-
import { z as z17 } from "zod";
|
|
322
|
-
|
|
323
|
-
// packages/contract/src/session-lifecycle.ts
|
|
324
|
-
import { z as z12 } from "zod";
|
|
325
|
-
var SESSION_LIFECYCLE_SCHEMA = z12.object({
|
|
326
|
-
desired: z12.enum(["run", "sleep", "stop"]),
|
|
327
|
-
vm: z12.enum(["none", "awake", "asleep", "unknown"]),
|
|
328
|
-
harness: z12.enum(["running", "suspended", "exited"]),
|
|
329
|
-
attachment: z12.enum(["local", "attached", "reattaching", "detached"])
|
|
330
|
-
});
|
|
331
|
-
|
|
332
|
-
// packages/contract/src/session-workspace.ts
|
|
333
|
-
import { z as z13 } from "zod";
|
|
334
|
-
var SESSION_WORKSPACE_SCHEMA = z13.object({
|
|
335
|
-
repoURL: z13.string(),
|
|
336
|
-
sha: z13.string(),
|
|
337
|
-
ref: z13.string().optional(),
|
|
338
|
-
materializedAt: z13.number()
|
|
339
|
-
});
|
|
340
|
-
|
|
341
|
-
// packages/contract/src/to-agent-session-id.ts
|
|
342
|
-
import { z as z14 } from "zod";
|
|
343
|
-
var AGENT_SESSION_ID_SCHEMA = z14.string().brand();
|
|
344
|
-
function toAgentSessionID(id) {
|
|
345
|
-
return AGENT_SESSION_ID_SCHEMA.parse(id);
|
|
346
|
-
}
|
|
347
|
-
|
|
348
|
-
// packages/contract/src/to-daemon-id.ts
|
|
349
|
-
import { z as z15 } from "zod";
|
|
350
|
-
var DAEMON_ID_SCHEMA = z15.string().brand();
|
|
351
|
-
function toDaemonID(id) {
|
|
352
|
-
return DAEMON_ID_SCHEMA.parse(id);
|
|
353
|
-
}
|
|
354
|
-
|
|
355
|
-
// packages/contract/src/to-session-id.ts
|
|
356
|
-
import { z as z16 } from "zod";
|
|
357
|
-
var SESSION_ID_SCHEMA = z16.string().brand();
|
|
358
|
-
function toSessionID(id) {
|
|
359
|
-
return SESSION_ID_SCHEMA.parse(id);
|
|
360
|
-
}
|
|
361
|
-
|
|
362
|
-
// packages/contract/src/session-descriptor.ts
|
|
363
|
-
var SESSION_HOST_SCHEMA = z17.object({
|
|
364
|
-
name: z17.string(),
|
|
365
|
-
id: z17.string().optional(),
|
|
366
|
-
issuer: z17.string().optional()
|
|
367
|
-
});
|
|
368
|
-
var SESSION_DESCRIPTOR_SCHEMA = z17.object({
|
|
369
|
-
id: z17.string().transform((id) => toSessionID(id)),
|
|
370
|
-
name: z17.string(),
|
|
371
|
-
cwd: z17.string(),
|
|
372
|
-
state: z17.enum(["running", "needs_you", "done", "exited"]),
|
|
373
|
-
unread: z17.boolean(),
|
|
374
|
-
lastMsg: z17.string(),
|
|
375
|
-
lastDetail: z17.string().optional(),
|
|
376
|
-
restoreRefusal: z17.string().optional(),
|
|
377
|
-
agentSessionID: z17.string().transform((id) => toAgentSessionID(id)).optional(),
|
|
378
|
-
agent: z17.string(),
|
|
379
|
-
pinned: z17.boolean(),
|
|
380
|
-
lastAttachedAt: z17.number(),
|
|
381
|
-
repoRoot: z17.string(),
|
|
382
|
-
namedBy: z17.enum(["user", "auto", "agent"]),
|
|
383
|
-
createdAt: z17.number(),
|
|
384
|
-
kind: z17.enum(["pty", "headless"]),
|
|
385
|
-
alive: z17.boolean(),
|
|
386
|
-
canEject: z17.boolean(),
|
|
387
|
-
parent: z17.string().transform((id) => toSessionID(id)).optional(),
|
|
388
|
-
locator: z17.object({
|
|
389
|
-
daemonID: z17.string().transform((id) => toDaemonID(id)),
|
|
390
|
-
targetID: z17.string()
|
|
391
|
-
}),
|
|
392
|
-
workspace: SESSION_WORKSPACE_SCHEMA.optional(),
|
|
393
|
-
lifecycle: SESSION_LIFECYCLE_SCHEMA,
|
|
394
|
-
model: z17.string().optional(),
|
|
395
|
-
pluginDirs: z17.array(z17.string()).readonly().optional(),
|
|
396
|
-
host: SESSION_HOST_SCHEMA.optional()
|
|
397
|
-
});
|
|
398
|
-
|
|
399
|
-
// packages/contract/src/daemon-event.ts
|
|
400
|
-
var SESSION_EVENT = z18.object({ session: SESSION_DESCRIPTOR_SCHEMA });
|
|
401
|
-
var DAEMON_EVENT_SCHEMA = z18.discriminatedUnion("ev", [
|
|
402
|
-
SESSION_EVENT.extend({ ev: z18.literal("SessionAdded") }),
|
|
403
|
-
SESSION_EVENT.extend({ ev: z18.literal("SessionState") }),
|
|
404
|
-
SESSION_EVENT.extend({ ev: z18.literal("SessionAttached") }),
|
|
405
|
-
SESSION_EVENT.extend({ ev: z18.literal("SessionDetached") }),
|
|
406
|
-
z18.object({
|
|
407
|
-
ev: z18.literal("SessionRenamed"),
|
|
408
|
-
sessionID: z18.string(),
|
|
409
|
-
name: z18.string(),
|
|
410
|
-
namedBy: z18.enum(["user", "auto", "agent"])
|
|
411
|
-
}),
|
|
412
|
-
z18.object({ ev: z18.literal("SessionRemoved"), sessionID: z18.string() }),
|
|
413
|
-
z18.object({
|
|
414
|
-
ev: z18.literal("SessionResized"),
|
|
415
|
-
sessionID: z18.string(),
|
|
416
|
-
cols: z18.number(),
|
|
417
|
-
rows: z18.number()
|
|
418
|
-
}),
|
|
419
|
-
z18.object({
|
|
420
|
-
ev: z18.literal("SessionOutput"),
|
|
421
|
-
sessionID: z18.string(),
|
|
422
|
-
seq: z18.number(),
|
|
423
|
-
data: z18.string()
|
|
424
|
-
}),
|
|
425
|
-
z18.object({ ev: z18.literal("SessionDesync"), sessionID: z18.string(), dropped: z18.number() }),
|
|
426
|
-
z18.object({
|
|
427
|
-
ev: z18.literal("PermissionRequested"),
|
|
428
|
-
request: z18.string(),
|
|
429
|
-
sessionID: z18.string(),
|
|
430
|
-
message: z18.string(),
|
|
431
|
-
respondable: z18.boolean()
|
|
432
|
-
}),
|
|
433
|
-
z18.object({ ev: z18.literal("PermissionResolved"), request: z18.string(), decision: z18.string() }),
|
|
434
|
-
z18.object({
|
|
435
|
-
ev: z18.literal("SessionMessage"),
|
|
436
|
-
sessionID: z18.string(),
|
|
437
|
-
message: z18.string(),
|
|
438
|
-
status: MESSAGE_STATUS_SCHEMA,
|
|
439
|
-
from: z18.string(),
|
|
440
|
-
sender: MESSAGE_SENDER_SCHEMA.optional(),
|
|
441
|
-
textPreview: z18.string(),
|
|
442
|
-
sentAt: z18.number(),
|
|
443
|
-
deliveredAt: z18.number().optional(),
|
|
444
|
-
answeredAt: z18.number().optional(),
|
|
445
|
-
answerPreview: z18.string().optional(),
|
|
446
|
-
unansweredAt: z18.number().optional(),
|
|
447
|
-
unansweredReason: z18.string().optional()
|
|
448
|
-
}),
|
|
449
|
-
z18.object({
|
|
450
|
-
ev: z18.literal("SessionNote"),
|
|
451
|
-
sessionID: z18.string(),
|
|
452
|
-
kind: z18.string(),
|
|
453
|
-
text: z18.string(),
|
|
454
|
-
sentAt: z18.number()
|
|
455
|
-
}),
|
|
456
|
-
z18.object({
|
|
457
|
-
ev: z18.literal("InboxMessage"),
|
|
458
|
-
sessionID: z18.string(),
|
|
459
|
-
message: z18.string(),
|
|
460
|
-
from: z18.string(),
|
|
461
|
-
sender: MESSAGE_SENDER_SCHEMA.optional(),
|
|
462
|
-
text: z18.string(),
|
|
463
|
-
sentAt: z18.number()
|
|
464
|
-
}),
|
|
465
|
-
z18.object({
|
|
466
|
-
ev: z18.literal("InboxNotice"),
|
|
467
|
-
sessionID: z18.string(),
|
|
468
|
-
message: z18.string(),
|
|
469
|
-
from: z18.string(),
|
|
470
|
-
status: z18.enum(["answered", "unanswered"]),
|
|
471
|
-
answer: z18.string().optional(),
|
|
472
|
-
reason: z18.string().optional(),
|
|
473
|
-
at: z18.number()
|
|
474
|
-
}),
|
|
475
|
-
z18.object({
|
|
476
|
-
ev: z18.literal("InboxClosed"),
|
|
477
|
-
sessionID: z18.string(),
|
|
478
|
-
reason: z18.enum(["replaced", "removed"])
|
|
479
|
-
}),
|
|
480
|
-
z18.object({ ev: z18.literal("DaemonRestarted"), result: RESTART_RESULT_SCHEMA })
|
|
481
|
-
]);
|
|
482
|
-
|
|
483
|
-
// packages/contract/src/events-page.ts
|
|
484
|
-
import { z as z20 } from "zod";
|
|
485
|
-
|
|
486
|
-
// packages/contract/src/fleet-event.ts
|
|
487
|
-
import { z as z19 } from "zod";
|
|
488
|
-
var FLEET_EVENT_SCHEMA = z19.object({
|
|
489
|
-
cursor: z19.string(),
|
|
490
|
-
at: z19.number(),
|
|
491
|
-
session: z19.string(),
|
|
492
|
-
name: z19.string().nullable(),
|
|
493
|
-
kind: z19.string(),
|
|
494
|
-
detail: z19.string().nullable(),
|
|
495
|
-
message: z19.string().optional(),
|
|
496
|
-
label: z19.string().optional(),
|
|
497
|
-
result: RESTART_RESULT_SCHEMA.optional(),
|
|
498
|
-
origin: z19.object({ daemon: z19.string(), incarnation: z19.string(), cursor: z19.string() }).optional()
|
|
499
|
-
});
|
|
500
|
-
|
|
501
|
-
// packages/contract/src/events-page.ts
|
|
502
|
-
var EVENTS_PAGE_SCHEMA = z20.object({
|
|
503
|
-
events: z20.array(FLEET_EVENT_SCHEMA).readonly(),
|
|
504
|
-
cursor: z20.string(),
|
|
505
|
-
more: z20.boolean()
|
|
506
|
-
});
|
|
507
|
-
|
|
508
|
-
// packages/contract/src/fleet-entry-view.ts
|
|
509
|
-
import { z as z21 } from "zod";
|
|
510
|
-
var FLEET_ENTRY_VIEW_SCHEMA = z21.object({
|
|
511
|
-
sessionID: z21.string(),
|
|
512
|
-
name: z21.string(),
|
|
513
|
-
cwd: z21.string(),
|
|
514
|
-
agentSessionID: z21.string().optional(),
|
|
515
|
-
agent: z21.string(),
|
|
516
|
-
pinned: z21.boolean().optional(),
|
|
517
|
-
lastAttachedAt: z21.number().optional(),
|
|
518
|
-
exited: z21.boolean().optional(),
|
|
519
|
-
parent: z21.string().optional(),
|
|
520
|
-
prompt: z21.string().optional(),
|
|
521
|
-
result: z21.string().optional(),
|
|
522
|
-
transcriptPath: z21.string().optional(),
|
|
523
|
-
model: z21.string().optional(),
|
|
524
|
-
effort: z21.string().optional(),
|
|
525
|
-
pluginDirs: z21.array(z21.string()).readonly().optional(),
|
|
526
|
-
target: z21.string().optional(),
|
|
527
|
-
targetIdentity: z21.string().optional(),
|
|
528
|
-
workspace: SESSION_WORKSPACE_SCHEMA.optional(),
|
|
529
|
-
withheldEnv: z21.array(z21.string()).readonly().optional(),
|
|
530
|
-
desired: z21.enum(["sleep", "stop"]).optional(),
|
|
531
|
-
hostKey: z21.string().optional()
|
|
532
|
-
});
|
|
533
|
-
|
|
534
|
-
// packages/contract/src/git-probe-result.ts
|
|
535
|
-
import { z as z23 } from "zod";
|
|
536
|
-
|
|
537
|
-
// packages/contract/src/git-ref.ts
|
|
538
|
-
import { z as z22 } from "zod";
|
|
539
|
-
var GIT_REF_SCHEMA = z22.object({
|
|
540
|
-
name: z22.string(),
|
|
541
|
-
kind: z22.enum(["branch", "tag"]),
|
|
542
|
-
sha: z22.string()
|
|
543
|
-
});
|
|
544
|
-
|
|
545
|
-
// packages/contract/src/git-probe-result.ts
|
|
546
|
-
var GIT_PROBE_RESULT_SCHEMA = z23.object({
|
|
547
|
-
url: z23.string(),
|
|
548
|
-
head: z23.string().nullable(),
|
|
549
|
-
refs: z23.array(GIT_REF_SCHEMA).readonly(),
|
|
550
|
-
resolved: z23.object({ sha: z23.string(), branch: z23.string().nullable() }).nullable()
|
|
551
|
-
});
|
|
552
|
-
|
|
553
|
-
// packages/contract/src/hello-result.ts
|
|
554
|
-
import { z as z24 } from "zod";
|
|
555
|
-
var HELLO_RESULT_SCHEMA = z24.object({
|
|
556
|
-
daemon: z24.string(),
|
|
557
|
-
daemonID: z24.string(),
|
|
558
|
-
limits: z24.object({ maxLine: z24.number(), maxChunk: z24.number() }),
|
|
559
|
-
idempotency: z24.object({ completedRetentionMs: z24.number() }),
|
|
560
|
-
lastUsedAgent: z24.string(),
|
|
561
|
-
peerSession: z24.string().nullable(),
|
|
562
|
-
features: z24.array(z24.string()).readonly().default([])
|
|
563
|
-
});
|
|
564
|
-
|
|
565
|
-
// packages/contract/src/menu-view.ts
|
|
566
|
-
import { z as z25 } from "zod";
|
|
567
|
-
var MENU_VIEW_SCHEMA = z25.object({
|
|
568
|
-
text: z25.string(),
|
|
569
|
-
options: z25.array(buildMenuOptionSchema()).readonly(),
|
|
570
|
-
menuToken: z25.string()
|
|
571
|
-
});
|
|
572
|
-
function buildMenuOptionSchema() {
|
|
573
|
-
return z25.object({
|
|
574
|
-
option: z25.number(),
|
|
575
|
-
label: z25.string(),
|
|
576
|
-
checked: z25.boolean().nullable(),
|
|
577
|
-
highlighted: z25.boolean()
|
|
578
|
-
});
|
|
579
|
-
}
|
|
580
|
-
|
|
581
|
-
// packages/contract/src/message-answer.ts
|
|
582
|
-
import { z as z26 } from "zod";
|
|
583
|
-
var MESSAGE_ANSWER_SCHEMA = z26.object({
|
|
584
|
-
message: z26.string(),
|
|
585
|
-
status: MESSAGE_STATUS_SCHEMA
|
|
586
|
-
});
|
|
587
|
-
|
|
588
|
-
// packages/contract/src/message-view.ts
|
|
589
|
-
import { z as z27 } from "zod";
|
|
590
|
-
var MESSAGE_VIEW_SCHEMA = z27.object({
|
|
591
|
-
message: z27.string(),
|
|
592
|
-
session: z27.string(),
|
|
593
|
-
from: z27.string(),
|
|
594
|
-
sender: MESSAGE_SENDER_SCHEMA.optional(),
|
|
595
|
-
text: z27.string(),
|
|
596
|
-
status: MESSAGE_STATUS_SCHEMA,
|
|
597
|
-
sentAt: z27.number(),
|
|
598
|
-
deliveredAt: z27.number().optional(),
|
|
599
|
-
answeredAt: z27.number().optional(),
|
|
600
|
-
answer: z27.string().optional(),
|
|
601
|
-
unansweredAt: z27.number().optional(),
|
|
602
|
-
unansweredReason: z27.string().optional(),
|
|
603
|
-
turn: z27.string().nullable(),
|
|
604
|
-
answeredWith: z27.array(z27.string()).readonly()
|
|
605
|
-
});
|
|
606
|
-
|
|
607
|
-
// packages/contract/src/note-view.ts
|
|
608
|
-
import { z as z28 } from "zod";
|
|
609
|
-
var NOTE_VIEW_SCHEMA = z28.object({
|
|
610
|
-
note: z28.string(),
|
|
611
|
-
at: z28.number(),
|
|
612
|
-
session: z28.string(),
|
|
613
|
-
name: z28.string().nullable(),
|
|
614
|
-
label: z28.string(),
|
|
615
|
-
text: z28.string(),
|
|
616
|
-
complete: z28.boolean()
|
|
617
|
-
});
|
|
618
|
-
|
|
619
|
-
// packages/contract/src/published-record-schema.ts
|
|
620
|
-
import { z as z29 } from "zod";
|
|
621
|
-
var WORKSPACE_SCOPE_SCHEMA = z29.object({
|
|
622
|
-
path: z29.string(),
|
|
623
|
-
branch: z29.string().nullable(),
|
|
624
|
-
repoURL: z29.string().nullable(),
|
|
625
|
-
sha: z29.string().nullable()
|
|
626
|
-
});
|
|
627
|
-
var WORKTREE_SCOPE_SCHEMA = z29.object({ path: z29.string(), branch: z29.string().nullable() });
|
|
628
|
-
var BRANCH_SCOPE_SCHEMA = z29.object({ name: z29.string(), repo: z29.string() });
|
|
629
|
-
var PULL_REQUEST_SCOPE_SCHEMA = z29.object({
|
|
630
|
-
repo: z29.string(),
|
|
631
|
-
number: z29.number(),
|
|
632
|
-
url: z29.string(),
|
|
633
|
-
branch: z29.string()
|
|
634
|
-
});
|
|
635
|
-
var SCOPE_SCHEMA = z29.object({
|
|
636
|
-
workspace: WORKSPACE_SCOPE_SCHEMA,
|
|
637
|
-
worktrees: z29.array(WORKTREE_SCOPE_SCHEMA),
|
|
638
|
-
branches: z29.array(BRANCH_SCOPE_SCHEMA),
|
|
639
|
-
pullRequests: z29.array(PULL_REQUEST_SCOPE_SCHEMA)
|
|
640
|
-
});
|
|
641
|
-
var PUBLISHED_RECORD_SCHEMA = z29.object({
|
|
642
|
-
format: z29.literal("atc.session-record"),
|
|
643
|
-
version: z29.literal(1),
|
|
644
|
-
session: z29.string(),
|
|
645
|
-
daemonID: z29.string(),
|
|
646
|
-
target: z29.string(),
|
|
647
|
-
revision: z29.number().int().min(1),
|
|
648
|
-
updatedAt: z29.string(),
|
|
649
|
-
name: z29.string().nullable(),
|
|
650
|
-
transcriptPath: z29.string().nullable(),
|
|
651
|
-
spawner: z29.string().nullable(),
|
|
652
|
-
scratch: z29.string().nullable(),
|
|
653
|
-
scope: SCOPE_SCHEMA
|
|
654
|
-
});
|
|
655
|
-
|
|
656
|
-
// packages/contract/src/request-param-schemas.ts
|
|
657
|
-
import { z as z31 } from "zod";
|
|
658
|
-
|
|
659
|
-
// packages/contract/src/grant-scope.ts
|
|
660
|
-
var GRANT_SCOPES = ["read", "message", "spawn", "kill"];
|
|
739
|
+
// packages/contract/src/daemon-contract/request-param-schemas.ts
|
|
740
|
+
import { z as z38 } from "zod";
|
|
661
741
|
|
|
662
|
-
// packages/contract/src/to-message-id.ts
|
|
663
|
-
import { z as
|
|
664
|
-
var MESSAGE_ID_SCHEMA =
|
|
742
|
+
// packages/contract/src/ids/to-message-id.ts
|
|
743
|
+
import { z as z37 } from "zod";
|
|
744
|
+
var MESSAGE_ID_SCHEMA = z37.string().brand();
|
|
665
745
|
function toMessageID(id) {
|
|
666
746
|
return MESSAGE_ID_SCHEMA.parse(id);
|
|
667
747
|
}
|
|
668
748
|
|
|
669
|
-
// packages/contract/src/
|
|
749
|
+
// packages/contract/src/sessions/grant-scope.ts
|
|
750
|
+
var GRANT_SCOPES = ["read", "message", "spawn", "kill"];
|
|
751
|
+
|
|
752
|
+
// packages/contract/src/daemon-contract/request-param-schemas.ts
|
|
670
753
|
var EJECT_DEFAULT_PROMPT = "Continue the task autonomously. Verify your work as you go and stop when it is complete.";
|
|
671
|
-
var SESSION_DEFAULTED =
|
|
754
|
+
var SESSION_DEFAULTED = z38.object({
|
|
672
755
|
session: buildDefaultedString("").transform(toSessionID)
|
|
673
756
|
});
|
|
674
|
-
var IDEMPOTENCY_KEY =
|
|
675
|
-
var REPLAY_ONLY =
|
|
676
|
-
var CREDENTIAL_REF =
|
|
677
|
-
kind:
|
|
678
|
-
name:
|
|
757
|
+
var IDEMPOTENCY_KEY = z38.string({ error: "idempotencyKey must be a string" }).min(1, "idempotencyKey must not be empty").max(200, "idempotencyKey must be at most 200 characters").optional();
|
|
758
|
+
var REPLAY_ONLY = z38.boolean({ error: "replayOnly must be a boolean" }).optional();
|
|
759
|
+
var CREDENTIAL_REF = z38.strictObject({
|
|
760
|
+
kind: z38.literal("env"),
|
|
761
|
+
name: z38.string().regex(/^[A-Za-z_]\w*$/u, "a credentialRef names an environment variable")
|
|
679
762
|
});
|
|
680
|
-
var GIT_URL =
|
|
681
|
-
var GIT_REF =
|
|
682
|
-
var GIT_SHA =
|
|
683
|
-
var WORKSPACE_SOURCE =
|
|
684
|
-
|
|
685
|
-
kind:
|
|
686
|
-
path:
|
|
687
|
-
allowDirty:
|
|
763
|
+
var GIT_URL = z38.string({ error: "a git workspace requires a url" }).min(1, "a git workspace requires a url").refine((url) => !url.startsWith("-"), "a git workspace url must not start with -");
|
|
764
|
+
var GIT_REF = z38.string().min(1, "a git workspace ref must not be empty").refine((ref) => !ref.startsWith("-"), "a git workspace ref must not start with -");
|
|
765
|
+
var GIT_SHA = z38.string().regex(COMMIT_ID_PATTERN, "a git workspace sha is a full commit id");
|
|
766
|
+
var WORKSPACE_SOURCE = z38.discriminatedUnion("kind", [
|
|
767
|
+
z38.strictObject({
|
|
768
|
+
kind: z38.literal("path"),
|
|
769
|
+
path: z38.string({ error: "a path workspace requires an absolute path" }).startsWith("/", "a path workspace requires an absolute path"),
|
|
770
|
+
allowDirty: z38.enum(["refuse", "warn"]).optional()
|
|
688
771
|
}),
|
|
689
|
-
|
|
690
|
-
kind:
|
|
772
|
+
z38.strictObject({
|
|
773
|
+
kind: z38.literal("git"),
|
|
691
774
|
url: GIT_URL,
|
|
692
775
|
ref: GIT_REF.optional(),
|
|
693
776
|
sha: GIT_SHA.optional(),
|
|
@@ -696,50 +779,50 @@ var WORKSPACE_SOURCE = z31.discriminatedUnion("kind", [
|
|
|
696
779
|
message: "a git workspace takes a ref, a sha, or both"
|
|
697
780
|
})
|
|
698
781
|
]);
|
|
699
|
-
var TARGET =
|
|
700
|
-
var SOURCE_ID =
|
|
701
|
-
var SOURCE_TEXT =
|
|
702
|
-
var CLIENT_CWD =
|
|
782
|
+
var TARGET = z38.string({ error: "target must be a non-empty target id" }).min(1, "target must be a non-empty target id").optional();
|
|
783
|
+
var SOURCE_ID = z38.string({ error: "source must be a source id" }).min(1, "source must be a source id").max(64, "source must be a source id");
|
|
784
|
+
var SOURCE_TEXT = z38.string({ error: "source text must be a string" }).max(4096, "source text must be at most 4096 characters");
|
|
785
|
+
var CLIENT_CWD = z38.string({ error: "clientCwd must be an absolute path" }).startsWith("/", "clientCwd must be an absolute path").max(4096, "clientCwd must be at most 4096 characters");
|
|
703
786
|
var TERMINAL_SIZE_ERROR = "cols and rows must be whole numbers from 1 to 4096";
|
|
704
787
|
var REQUEST_PARAM_SCHEMAS = {
|
|
705
|
-
"daemon.hello":
|
|
788
|
+
"daemon.hello": z38.object({
|
|
706
789
|
client: buildDefaultedString("unknown client"),
|
|
707
|
-
protocol:
|
|
708
|
-
principal:
|
|
709
|
-
viewer:
|
|
710
|
-
session:
|
|
790
|
+
protocol: z38.number({ error: "daemon.hello protocol must be a number" }).optional(),
|
|
791
|
+
principal: z38.string({ error: "daemon.hello principal must be a non-empty string" }).min(1, "daemon.hello principal must be a non-empty string").optional(),
|
|
792
|
+
viewer: z38.string({ error: "daemon.hello viewer must be a non-empty string" }).min(1, "daemon.hello viewer must be a non-empty string").optional(),
|
|
793
|
+
session: z38.preprocess((input) => typeof input === "string" && input !== "" ? input : undefined, z38.string().transform(toSessionID).optional())
|
|
711
794
|
}),
|
|
712
|
-
"daemon.ping":
|
|
713
|
-
"daemon.quit":
|
|
714
|
-
"daemon.backup":
|
|
715
|
-
path:
|
|
795
|
+
"daemon.ping": z38.object({}),
|
|
796
|
+
"daemon.quit": z38.object({}),
|
|
797
|
+
"daemon.backup": z38.object({
|
|
798
|
+
path: z38.string({ error: "daemon.backup path must be an absolute path" }).refine((path) => path.startsWith("/"), "daemon.backup path must be an absolute path")
|
|
716
799
|
}),
|
|
717
|
-
"daemon.restarted":
|
|
718
|
-
"workspaces.prune":
|
|
719
|
-
remove:
|
|
800
|
+
"daemon.restarted": z38.object({ result: RESTART_RESULT_SCHEMA }),
|
|
801
|
+
"workspaces.prune": z38.object({
|
|
802
|
+
remove: z38.boolean({ error: "workspaces.prune remove must be a boolean" }).optional()
|
|
720
803
|
}),
|
|
721
|
-
"session.list":
|
|
722
|
-
"dirs.list":
|
|
723
|
-
"agents.list":
|
|
724
|
-
"sources.list":
|
|
804
|
+
"session.list": z38.object({}),
|
|
805
|
+
"dirs.list": z38.object({}),
|
|
806
|
+
"agents.list": z38.object({}),
|
|
807
|
+
"sources.list": z38.object({
|
|
725
808
|
source: SOURCE_ID,
|
|
726
809
|
target: TARGET,
|
|
727
810
|
scope: SOURCE_TEXT.min(1, "scope must be non-empty").optional(),
|
|
728
811
|
text: SOURCE_TEXT.optional()
|
|
729
812
|
}),
|
|
730
|
-
"sources.interpret":
|
|
813
|
+
"sources.interpret": z38.object({
|
|
731
814
|
source: SOURCE_ID,
|
|
732
815
|
input: SOURCE_TEXT,
|
|
733
816
|
target: TARGET,
|
|
734
817
|
clientCwd: CLIENT_CWD.optional()
|
|
735
818
|
}),
|
|
736
|
-
"sources.complete":
|
|
819
|
+
"sources.complete": z38.object({
|
|
737
820
|
source: SOURCE_ID,
|
|
738
821
|
input: SOURCE_TEXT,
|
|
739
822
|
target: TARGET,
|
|
740
823
|
clientCwd: CLIENT_CWD.optional()
|
|
741
824
|
}),
|
|
742
|
-
"git.probe":
|
|
825
|
+
"git.probe": z38.object({
|
|
743
826
|
url: GIT_URL,
|
|
744
827
|
ref: GIT_REF.optional(),
|
|
745
828
|
sha: GIT_SHA.optional(),
|
|
@@ -748,53 +831,53 @@ var REQUEST_PARAM_SCHEMAS = {
|
|
|
748
831
|
}).refine((probe) => probe.ref === undefined || probe.sha === undefined, {
|
|
749
832
|
message: "git.probe takes at most one of ref or sha"
|
|
750
833
|
}),
|
|
751
|
-
"fleet.list":
|
|
752
|
-
"fleet.restore":
|
|
834
|
+
"fleet.list": z38.object({}),
|
|
835
|
+
"fleet.restore": z38.object({
|
|
753
836
|
cols: buildTerminalSize(80),
|
|
754
837
|
rows: buildTerminalSize(24)
|
|
755
838
|
}),
|
|
756
|
-
"session.spawn":
|
|
757
|
-
cwd:
|
|
839
|
+
"session.spawn": z38.object({
|
|
840
|
+
cwd: z38.string({ error: "session.spawn requires a cwd" }).min(1, "session.spawn requires a cwd").optional(),
|
|
758
841
|
name: buildDefaultedString(""),
|
|
759
842
|
prompt: buildDefaultedString(""),
|
|
760
843
|
cols: buildTerminalSize(80),
|
|
761
844
|
rows: buildTerminalSize(24),
|
|
762
845
|
resume: buildDefaultedBooleanOrString(false).transform((value) => typeof value === "string" ? toAgentSessionID(value) : value),
|
|
763
|
-
agent:
|
|
764
|
-
model:
|
|
765
|
-
effort:
|
|
766
|
-
pluginDirs:
|
|
846
|
+
agent: z38.string({ error: "session.spawn agent must be a non-empty agent id" }).min(1, "session.spawn agent must be a non-empty agent id").optional(),
|
|
847
|
+
model: z38.string({ error: "session.spawn model must be a string" }).optional(),
|
|
848
|
+
effort: z38.string({ error: "session.spawn effort must be a string" }).optional(),
|
|
849
|
+
pluginDirs: z38.array(z38.string({ error: "session.spawn pluginDirs must be an array of strings" }), {
|
|
767
850
|
error: "session.spawn pluginDirs must be an array of strings"
|
|
768
851
|
}).max(32, "session.spawn pluginDirs takes at most 32 folders").optional(),
|
|
769
852
|
idempotencyKey: IDEMPOTENCY_KEY,
|
|
770
853
|
replayOnly: REPLAY_ONLY,
|
|
771
|
-
target:
|
|
854
|
+
target: z38.string({ error: "session.spawn target must be a non-empty target id" }).min(1, "session.spawn target must be a non-empty target id").optional(),
|
|
772
855
|
workspace: WORKSPACE_SOURCE.optional(),
|
|
773
|
-
trustClonedWorkspace:
|
|
774
|
-
scope:
|
|
775
|
-
parent:
|
|
776
|
-
atcAccess:
|
|
856
|
+
trustClonedWorkspace: z38.boolean({ error: "session.spawn trustClonedWorkspace must be a boolean" }).optional(),
|
|
857
|
+
scope: z38.unknown().optional(),
|
|
858
|
+
parent: z38.preprocess((input) => typeof input === "string" && input !== "" ? input : undefined, z38.string().transform(toSessionID).optional()),
|
|
859
|
+
atcAccess: z38.array(z38.enum(GRANT_SCOPES, {
|
|
777
860
|
error: "session.spawn atcAccess takes read, message, spawn and kill"
|
|
778
861
|
}), {
|
|
779
862
|
error: "session.spawn atcAccess must be an array of scopes"
|
|
780
863
|
}).max(GRANT_SCOPES.length, "session.spawn atcAccess names each scope once").refine((scopes) => new Set(scopes).size === scopes.length, "session.spawn atcAccess names each scope once").optional()
|
|
781
864
|
}),
|
|
782
865
|
"session.kill": SESSION_DEFAULTED.extend({
|
|
783
|
-
stopOnly:
|
|
866
|
+
stopOnly: z38.boolean({ error: "session.kill stopOnly must be a boolean" }).optional()
|
|
784
867
|
}),
|
|
785
868
|
"session.ack": SESSION_DEFAULTED,
|
|
786
869
|
"session.forget": SESSION_DEFAULTED.extend({
|
|
787
|
-
confirmToken:
|
|
788
|
-
refusePinned:
|
|
789
|
-
refuseLive:
|
|
870
|
+
confirmToken: z38.string({ error: "session.forget confirmToken must be a string" }).min(1, "session.forget confirmToken must not be empty").optional(),
|
|
871
|
+
refusePinned: z38.boolean({ error: "session.forget refusePinned must be a boolean" }).optional(),
|
|
872
|
+
refuseLive: z38.boolean({ error: "session.forget refuseLive must be a boolean" }).optional()
|
|
790
873
|
}),
|
|
791
874
|
"session.auth.revoke": SESSION_DEFAULTED,
|
|
792
875
|
"session.auth.rebind": SESSION_DEFAULTED,
|
|
793
|
-
"session.scope.add": SESSION_DEFAULTED.extend({ scope:
|
|
876
|
+
"session.scope.add": SESSION_DEFAULTED.extend({ scope: z38.unknown() }),
|
|
794
877
|
"session.update": SESSION_DEFAULTED.extend({
|
|
795
878
|
name: buildOptionalString(),
|
|
796
879
|
pinned: buildOptionalBoolean(),
|
|
797
|
-
parent:
|
|
880
|
+
parent: z38.null({ error: "session.update parent must be null" }).optional()
|
|
798
881
|
}),
|
|
799
882
|
"session.attach": SESSION_DEFAULTED.extend({
|
|
800
883
|
cols: buildTerminalSize(80),
|
|
@@ -818,10 +901,10 @@ var REQUEST_PARAM_SCHEMAS = {
|
|
|
818
901
|
"session.screen": SESSION_DEFAULTED,
|
|
819
902
|
"session.menu": SESSION_DEFAULTED,
|
|
820
903
|
"session.choose": SESSION_DEFAULTED.extend({
|
|
821
|
-
menuToken:
|
|
822
|
-
option:
|
|
823
|
-
label:
|
|
824
|
-
key:
|
|
904
|
+
menuToken: z38.string({ error: "session.choose requires the menuToken of the menu it answers" }).min(1, "session.choose requires the menuToken of the menu it answers"),
|
|
905
|
+
option: z38.number({ error: "option must be a number" }).int("option must be a whole number").min(1, "option counts from 1").optional(),
|
|
906
|
+
label: z38.string({ error: "label must be a string" }).optional(),
|
|
907
|
+
key: z38.literal("escape", { error: "key takes only 'escape'" }).optional()
|
|
825
908
|
}).refine((params) => params.key === undefined ? params.option !== undefined && params.label !== undefined : params.option === undefined, { message: "session.choose takes an option with its label, or key 'escape', not both" }),
|
|
826
909
|
"session.eject": SESSION_DEFAULTED.extend({
|
|
827
910
|
prompt: buildDefaultedNonEmptyString(EJECT_DEFAULT_PROMPT)
|
|
@@ -830,7 +913,7 @@ var REQUEST_PARAM_SCHEMAS = {
|
|
|
830
913
|
cols: buildTerminalSize(80),
|
|
831
914
|
rows: buildTerminalSize(24)
|
|
832
915
|
}),
|
|
833
|
-
"permission.respond":
|
|
916
|
+
"permission.respond": z38.object({
|
|
834
917
|
request: buildDefaultedString(""),
|
|
835
918
|
decision: buildDefaultedString("")
|
|
836
919
|
}).refine((params) => params.request !== "" && params.decision !== "", {
|
|
@@ -841,12 +924,12 @@ var REQUEST_PARAM_SCHEMAS = {
|
|
|
841
924
|
cursor: buildOptionalCursor(),
|
|
842
925
|
limit: buildDefaultedNumber(50).transform((value) => Math.min(Math.max(Math.trunc(value), 1), 200))
|
|
843
926
|
}),
|
|
844
|
-
"events.read":
|
|
927
|
+
"events.read": z38.object({
|
|
845
928
|
cursor: buildOptionalCursor(),
|
|
846
|
-
from:
|
|
929
|
+
from: z38.literal("start", { error: "events.read takes from only as 'start'" }).optional(),
|
|
847
930
|
limit: buildDefaultedNumber(50).transform((value) => Math.min(Math.max(Math.trunc(value), 1), 200)),
|
|
848
931
|
waitMs: buildDefaultedWait(),
|
|
849
|
-
session:
|
|
932
|
+
session: z38.preprocess((input) => typeof input === "string" && input !== "" ? input : undefined, z38.string().transform(toSessionID).optional())
|
|
850
933
|
}).refine((params) => params.cursor === undefined || params.from === undefined, {
|
|
851
934
|
message: "events.read takes a cursor or from, not both"
|
|
852
935
|
}),
|
|
@@ -854,20 +937,20 @@ var REQUEST_PARAM_SCHEMAS = {
|
|
|
854
937
|
text: buildDefaultedString(""),
|
|
855
938
|
idempotencyKey: IDEMPOTENCY_KEY,
|
|
856
939
|
replayOnly: REPLAY_ONLY,
|
|
857
|
-
from:
|
|
858
|
-
notice:
|
|
940
|
+
from: z38.preprocess((input) => typeof input === "string" && input.trim() !== "" ? input.trim() : undefined, z38.string().max(200, "from must be at most 200 characters").optional()),
|
|
941
|
+
notice: z38.boolean({ error: "notice must be a boolean" }).optional()
|
|
859
942
|
}).refine((params) => params.text !== "", { message: "session.message requires text" }),
|
|
860
943
|
"session.tap": SESSION_DEFAULTED.extend({
|
|
861
|
-
notices:
|
|
944
|
+
notices: z38.boolean().default(false)
|
|
862
945
|
}),
|
|
863
|
-
"message.get":
|
|
946
|
+
"message.get": z38.object({
|
|
864
947
|
message: buildDefaultedString("").transform(toMessageID),
|
|
865
948
|
waitMs: buildDefaultedWait()
|
|
866
949
|
}).refine((params) => params.message !== "", { message: "message.get requires a message" }),
|
|
867
|
-
"note.get":
|
|
950
|
+
"note.get": z38.object({
|
|
868
951
|
note: buildDefaultedString("")
|
|
869
952
|
}).refine((params) => params.note !== "", { message: "note.get requires a note" }),
|
|
870
|
-
"answer.get":
|
|
953
|
+
"answer.get": z38.object({
|
|
871
954
|
answer: buildDefaultedString("")
|
|
872
955
|
}).refine((params) => params.answer !== "", { message: "answer.get requires an answer" }),
|
|
873
956
|
"message.ack": SESSION_DEFAULTED.extend({
|
|
@@ -878,111 +961,28 @@ var REQUEST_PARAM_SCHEMAS = {
|
|
|
878
961
|
}).refine((params) => params.message !== "", { message: "notice.ack requires a message" })
|
|
879
962
|
};
|
|
880
963
|
function buildDefaultedString(fallback) {
|
|
881
|
-
return
|
|
964
|
+
return z38.preprocess((input) => typeof input === "string" ? input : undefined, z38.string().default(fallback));
|
|
882
965
|
}
|
|
883
966
|
function buildTerminalSize(fallback) {
|
|
884
|
-
return
|
|
967
|
+
return z38.preprocess((input) => typeof input === "number" ? input : undefined, z38.number({ error: TERMINAL_SIZE_ERROR }).int(TERMINAL_SIZE_ERROR).min(1, TERMINAL_SIZE_ERROR).max(4096, TERMINAL_SIZE_ERROR).default(fallback));
|
|
885
968
|
}
|
|
886
969
|
function buildDefaultedBooleanOrString(fallback) {
|
|
887
|
-
return
|
|
970
|
+
return z38.preprocess((input) => typeof input === "boolean" || typeof input === "string" ? input : undefined, z38.union([z38.boolean(), z38.string()]).default(fallback));
|
|
888
971
|
}
|
|
889
972
|
function buildDefaultedNonEmptyString(fallback) {
|
|
890
|
-
return
|
|
973
|
+
return z38.preprocess((input) => typeof input === "string" && input !== "" ? input : undefined, z38.string().default(fallback));
|
|
891
974
|
}
|
|
892
975
|
function buildOptionalCursor() {
|
|
893
|
-
return
|
|
976
|
+
return z38.preprocess((input) => typeof input === "string" && input !== "" ? input : undefined, z38.string().optional());
|
|
894
977
|
}
|
|
895
978
|
function buildDefaultedNumber(fallback) {
|
|
896
|
-
return
|
|
979
|
+
return z38.preprocess((input) => typeof input === "number" ? input : undefined, z38.number().default(fallback));
|
|
897
980
|
}
|
|
898
981
|
function buildDefaultedWait() {
|
|
899
982
|
return buildDefaultedNumber(0).transform((value) => Math.min(Math.max(Math.trunc(value), 0), 30000));
|
|
900
983
|
}
|
|
901
984
|
|
|
902
|
-
// packages/contract/src/
|
|
903
|
-
import { z as z33 } from "zod";
|
|
904
|
-
|
|
905
|
-
// packages/contract/src/source-pick.ts
|
|
906
|
-
import { z as z32 } from "zod";
|
|
907
|
-
var SOURCE_PICK_SCHEMA = z32.discriminatedUnion("kind", [
|
|
908
|
-
z32.object({ kind: z32.literal("path"), directory: z32.string() }),
|
|
909
|
-
z32.object({ kind: z32.literal("git"), url: z32.string() })
|
|
910
|
-
]);
|
|
911
|
-
|
|
912
|
-
// packages/contract/src/source-candidate.ts
|
|
913
|
-
var SOURCE_CANDIDATE_SCHEMA = z33.object({
|
|
914
|
-
label: z33.string(),
|
|
915
|
-
detail: z33.string().optional(),
|
|
916
|
-
pick: SOURCE_PICK_SCHEMA
|
|
917
|
-
});
|
|
918
|
-
|
|
919
|
-
// packages/contract/src/source-interpretation.ts
|
|
920
|
-
import { z as z34 } from "zod";
|
|
921
|
-
var SOURCE_INTERPRETATION_SCHEMA = z34.union([
|
|
922
|
-
z34.object({ kind: z34.literal("browse"), scope: z34.string() }),
|
|
923
|
-
SOURCE_PICK_SCHEMA,
|
|
924
|
-
z34.object({ kind: z34.literal("none") })
|
|
925
|
-
]);
|
|
926
|
-
|
|
927
|
-
// packages/contract/src/spawn-answer.ts
|
|
928
|
-
import { z as z35 } from "zod";
|
|
929
|
-
var SPAWN_ANSWER_SCHEMA = z35.object({
|
|
930
|
-
session: SESSION_DESCRIPTOR_SCHEMA,
|
|
931
|
-
warnings: z35.array(z35.string()).readonly().optional()
|
|
932
|
-
});
|
|
933
|
-
|
|
934
|
-
// packages/contract/src/transcript-row.ts
|
|
935
|
-
import { z as z36 } from "zod";
|
|
936
|
-
var TRANSCRIPT_TOOL_SCHEMA = z36.object({ name: z36.string(), input: z36.string() });
|
|
937
|
-
var TRANSCRIPT_ROW_SCHEMA = z36.object({
|
|
938
|
-
role: z36.enum(["user", "assistant"]),
|
|
939
|
-
text: z36.string(),
|
|
940
|
-
tools: z36.array(TRANSCRIPT_TOOL_SCHEMA).readonly(),
|
|
941
|
-
at: z36.number().nullable()
|
|
942
|
-
});
|
|
943
|
-
|
|
944
|
-
// packages/contract/src/workspace-cleanup.ts
|
|
945
|
-
import { z as z37 } from "zod";
|
|
946
|
-
var STRINGS = z37.array(z37.string()).readonly();
|
|
947
|
-
var WORKSPACE_CLEANUP_SCHEMA = z37.discriminatedUnion("outcome", [
|
|
948
|
-
z37.object({ outcome: z37.literal("removed"), path: z37.string(), found: STRINGS }),
|
|
949
|
-
z37.object({ outcome: z37.literal("kept"), path: z37.string(), reasons: STRINGS }),
|
|
950
|
-
z37.object({ outcome: z37.literal("none") })
|
|
951
|
-
]);
|
|
952
|
-
|
|
953
|
-
// packages/contract/src/workspace-prune.ts
|
|
954
|
-
import { z as z38 } from "zod";
|
|
955
|
-
var STRINGS2 = z38.array(z38.string()).readonly();
|
|
956
|
-
var KIND = z38.enum(["workspace", "state"]);
|
|
957
|
-
var BYTES = z38.number().int().nonnegative().nullable();
|
|
958
|
-
var PRUNE_FOLDER_SCHEMA = z38.discriminatedUnion("verdict", [
|
|
959
|
-
z38.object({
|
|
960
|
-
verdict: z38.literal("remove"),
|
|
961
|
-
kind: KIND,
|
|
962
|
-
path: z38.string(),
|
|
963
|
-
bytes: BYTES,
|
|
964
|
-
found: STRINGS2
|
|
965
|
-
}),
|
|
966
|
-
z38.object({
|
|
967
|
-
verdict: z38.literal("keep"),
|
|
968
|
-
kind: KIND,
|
|
969
|
-
path: z38.string(),
|
|
970
|
-
bytes: BYTES,
|
|
971
|
-
reasons: STRINGS2
|
|
972
|
-
}),
|
|
973
|
-
z38.object({
|
|
974
|
-
verdict: z38.literal("skip"),
|
|
975
|
-
kind: z38.literal("workspace"),
|
|
976
|
-
path: z38.string(),
|
|
977
|
-
reason: z38.string()
|
|
978
|
-
})
|
|
979
|
-
]);
|
|
980
|
-
var WORKSPACE_PRUNE_SCHEMA = z38.object({
|
|
981
|
-
dryRun: z38.boolean(),
|
|
982
|
-
folders: z38.array(PRUNE_FOLDER_SCHEMA).readonly()
|
|
983
|
-
});
|
|
984
|
-
|
|
985
|
-
// packages/contract/src/daemon-contract.ts
|
|
985
|
+
// packages/contract/src/daemon-contract/daemon-contract.ts
|
|
986
986
|
var EMPTY = z39.object({});
|
|
987
987
|
var STRINGS3 = z39.array(z39.string()).readonly();
|
|
988
988
|
var FORGET_CONFIRM = z39.object({ confirmToken: z39.string(), expiresAt: z39.number() });
|
|
@@ -1098,7 +1098,7 @@ var DAEMON_CONTRACT = {
|
|
|
1098
1098
|
get: base.meta(READ).input(PARAMS["answer.get"]).output(ANSWER_VIEW_SCHEMA)
|
|
1099
1099
|
}
|
|
1100
1100
|
};
|
|
1101
|
-
// packages/contract/src/gateway-paths.ts
|
|
1101
|
+
// packages/contract/src/gateway/gateway-paths.ts
|
|
1102
1102
|
var GATEWAY_PATHS = {
|
|
1103
1103
|
browser: {
|
|
1104
1104
|
authorize: "/oauth2/authorize",
|
|
@@ -1121,16 +1121,16 @@ var GATEWAY_PATHS = {
|
|
|
1121
1121
|
ready: "/readyz"
|
|
1122
1122
|
}
|
|
1123
1123
|
};
|
|
1124
|
-
// packages/contract/src/gateway-registry-schema.ts
|
|
1124
|
+
// packages/contract/src/gateway/gateway-registry-schema.ts
|
|
1125
1125
|
import { z as z40 } from "zod";
|
|
1126
1126
|
|
|
1127
|
-
// packages/contract/src/max-events-cursor-bytes.ts
|
|
1127
|
+
// packages/contract/src/daemon-events/max-events-cursor-bytes.ts
|
|
1128
1128
|
var MAX_EVENTS_CURSOR_BYTES = 4096;
|
|
1129
1129
|
|
|
1130
|
-
// packages/contract/src/max-registry-daemons.ts
|
|
1130
|
+
// packages/contract/src/gateway/max-registry-daemons.ts
|
|
1131
1131
|
var MAX_REGISTRY_DAEMONS = 36;
|
|
1132
1132
|
|
|
1133
|
-
// packages/contract/src/gateway-registry-schema.ts
|
|
1133
|
+
// packages/contract/src/gateway/gateway-registry-schema.ts
|
|
1134
1134
|
var DAEMON_NAME_PATTERN = /^[a-z][a-z0-9-]{0,30}$/u;
|
|
1135
1135
|
var ADDRESS_PATTERN = /^(?:\[(?<v6>[^\]]+)\]|(?<host>[^:[\]]+)):(?<port>\d{1,5})$/u;
|
|
1136
1136
|
var ADDRESS_MESSAGE = "needs an address of <host>:<port> with a port from 1 to 65535";
|
|
@@ -1215,7 +1215,7 @@ var SESSION_ENV_NAMES = {
|
|
|
1215
1215
|
sessionRecord: "ATC_SESSION_RECORD",
|
|
1216
1216
|
scopeFile: "AUTO_MODE_SCOPE_FILE"
|
|
1217
1217
|
};
|
|
1218
|
-
// packages/contract/src/procedure-meta.ts
|
|
1218
|
+
// packages/contract/src/daemon-contract/procedure-meta.ts
|
|
1219
1219
|
import { z as z41 } from "zod";
|
|
1220
1220
|
var PROCEDURE_META_SCHEMA = z41.object({
|
|
1221
1221
|
access: z41.enum(["owner", "principal"]),
|