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