@atcx/contract 0.0.0-stage → 7.4.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (63) hide show
  1. package/LICENSE +21 -0
  2. package/README.md +59 -2
  3. package/dist/agent-list.d.ts +215 -0
  4. package/dist/agent-session-id.d.ts +2 -0
  5. package/dist/answer-view.d.ts +10 -0
  6. package/dist/check-daemon.d.ts +15 -0
  7. package/dist/commit-id-pattern.d.ts +1 -0
  8. package/dist/config-file-schema.d.ts +15 -0
  9. package/dist/contract-version.d.ts +1 -0
  10. package/dist/daemon-contract.d.ts +1646 -0
  11. package/dist/daemon-error-map.d.ts +9 -0
  12. package/dist/daemon-event.d.ts +424 -0
  13. package/dist/daemon-features.d.ts +2 -0
  14. package/dist/daemon-id.d.ts +2 -0
  15. package/dist/events-page.d.ts +39 -0
  16. package/dist/fleet-entry-view.d.ts +32 -0
  17. package/dist/fleet-event.d.ts +35 -0
  18. package/dist/git-probe-result.d.ts +18 -0
  19. package/dist/git-ref.d.ts +10 -0
  20. package/dist/hello-result.d.ts +16 -0
  21. package/dist/index.d.ts +45 -0
  22. package/dist/index.js +1121 -0
  23. package/dist/light/error-codes.d.ts +2 -0
  24. package/dist/light/index.d.ts +6 -0
  25. package/dist/light/index.js +131 -0
  26. package/dist/light/message-sender.d.ts +17 -0
  27. package/dist/light/resolve-atc-paths.d.ts +11 -0
  28. package/dist/light/resolve-home-dir.d.ts +1 -0
  29. package/dist/light/resolve-state-dir.d.ts +1 -0
  30. package/dist/light/session-env-names.d.ts +7 -0
  31. package/dist/menu-view.d.ts +12 -0
  32. package/dist/message-answer.d.ts +10 -0
  33. package/dist/message-id.d.ts +2 -0
  34. package/dist/message-status.d.ts +7 -0
  35. package/dist/message-view.d.ts +36 -0
  36. package/dist/note-view.d.ts +10 -0
  37. package/dist/procedure-meta.d.ts +10 -0
  38. package/dist/published-record-schema.d.ts +3 -0
  39. package/dist/published-record.d.ts +39 -0
  40. package/dist/request-param-schemas.d.ts +252 -0
  41. package/dist/restart-result.d.ts +28 -0
  42. package/dist/schema/build-optional-boolean.d.ts +2 -0
  43. package/dist/schema/build-optional-non-empty-string.d.ts +2 -0
  44. package/dist/schema/build-optional-string-array.d.ts +2 -0
  45. package/dist/schema/build-optional-string.d.ts +2 -0
  46. package/dist/schema/index.d.ts +4 -0
  47. package/dist/schema/index.js +26 -0
  48. package/dist/session-descriptor.d.ts +71 -0
  49. package/dist/session-id.d.ts +2 -0
  50. package/dist/session-lifecycle.d.ts +26 -0
  51. package/dist/session-workspace.d.ts +8 -0
  52. package/dist/source-candidate.d.ts +13 -0
  53. package/dist/source-entry.d.ts +10 -0
  54. package/dist/source-interpretation.d.ts +14 -0
  55. package/dist/source-pick.d.ts +9 -0
  56. package/dist/spawn-answer.d.ts +73 -0
  57. package/dist/spawn-option-spec.d.ts +16 -0
  58. package/dist/to-agent-session-id.d.ts +2 -0
  59. package/dist/to-daemon-id.d.ts +2 -0
  60. package/dist/to-message-id.d.ts +2 -0
  61. package/dist/to-session-id.d.ts +2 -0
  62. package/dist/transcript-row.d.ts +14 -0
  63. package/package.json +36 -4
package/dist/index.js ADDED
@@ -0,0 +1,1121 @@
1
+ // packages/contract/src/agent-list.ts
2
+ import { z as z3 } from "zod";
3
+
4
+ // packages/contract/src/source-entry.ts
5
+ import { z } from "zod";
6
+ var SOURCE_ENTRY_SCHEMA = z.object({
7
+ id: z.string(),
8
+ label: z.string(),
9
+ kind: z.enum(["path", "git"])
10
+ });
11
+
12
+ // packages/contract/src/spawn-option-spec.ts
13
+ import { z as z2 } from "zod";
14
+ var SPAWN_OPTION_EXAMPLE_SCHEMA = z2.object({
15
+ value: z2.string(),
16
+ resolvesTo: z2.string().nullable()
17
+ });
18
+ var SPAWN_OPTION_SPEC_SCHEMA = z2.object({
19
+ supported: z2.boolean(),
20
+ values: z2.array(z2.string()).readonly().nullable(),
21
+ examples: z2.array(SPAWN_OPTION_EXAMPLE_SCHEMA).readonly(),
22
+ default: z2.string().nullable(),
23
+ backendEffect: z2.enum(["applied", "unverified"]).nullable(),
24
+ note: z2.string().nullable()
25
+ });
26
+
27
+ // packages/contract/src/agent-list.ts
28
+ var SPAWN_OPTION_ENTRY_SCHEMA = SPAWN_OPTION_SPEC_SCHEMA.extend({ available: z3.boolean() });
29
+ var AGENT_ENTRY_SCHEMA = z3.object({
30
+ id: z3.string(),
31
+ label: z3.string(),
32
+ kind: z3.string(),
33
+ installed: z3.boolean(),
34
+ brokerAuth: z3.boolean(),
35
+ brokerRequired: z3.boolean(),
36
+ spawnTargets: z3.array(z3.string()).readonly(),
37
+ capabilities: z3.object({
38
+ spawn: z3.boolean(),
39
+ readTranscript: z3.boolean(),
40
+ message: z3.boolean(),
41
+ attach: z3.boolean(),
42
+ screen: z3.boolean(),
43
+ input: z3.boolean()
44
+ }),
45
+ models: z3.record(z3.string(), z3.string()).nullable(),
46
+ spawnOptions: z3.object({
47
+ model: SPAWN_OPTION_ENTRY_SCHEMA,
48
+ effort: SPAWN_OPTION_ENTRY_SCHEMA,
49
+ pluginDirs: SPAWN_OPTION_ENTRY_SCHEMA
50
+ })
51
+ });
52
+ var EXECUTION_CAPABILITIES_SCHEMA = z3.object({
53
+ spawn: z3.boolean(),
54
+ attach: z3.boolean(),
55
+ input: z3.boolean(),
56
+ resize: z3.boolean(),
57
+ kill: z3.boolean(),
58
+ transfer: z3.boolean(),
59
+ run: z3.boolean(),
60
+ headless: z3.boolean(),
61
+ suspend: z3.boolean(),
62
+ destroy: z3.boolean()
63
+ });
64
+ var TARGET_ENTRY_SCHEMA = z3.object({
65
+ id: z3.string(),
66
+ provider: z3.string(),
67
+ identity: z3.string(),
68
+ available: z3.boolean(),
69
+ remote: z3.boolean(),
70
+ default: z3.boolean(),
71
+ capabilities: EXECUTION_CAPABILITIES_SCHEMA,
72
+ brokerAuth: z3.boolean()
73
+ });
74
+ var TARGET_CONFIG_ERROR_SCHEMA = z3.union([
75
+ z3.object({
76
+ scope: z3.enum(["targets", "target", "defaultTarget"]),
77
+ target: z3.string().optional(),
78
+ problem: z3.string()
79
+ }),
80
+ z3.object({
81
+ scope: z3.literal("config"),
82
+ problem: z3.enum(["config_malformed", "config_unreadable"]),
83
+ path: z3.string(),
84
+ detail: z3.string()
85
+ })
86
+ ]);
87
+ var AGENT_LIST_SCHEMA = z3.object({
88
+ daemon: z3.object({
89
+ hostname: z3.string(),
90
+ platform: z3.string(),
91
+ arch: z3.string(),
92
+ build: z3.string()
93
+ }),
94
+ agents: z3.array(AGENT_ENTRY_SCHEMA).readonly(),
95
+ targets: z3.array(TARGET_ENTRY_SCHEMA).readonly(),
96
+ spawnDefaults: z3.object({ agent: z3.string(), target: z3.string().nullable() }),
97
+ configRevision: z3.string(),
98
+ targetErrors: z3.array(TARGET_CONFIG_ERROR_SCHEMA).readonly(),
99
+ sources: z3.array(SOURCE_ENTRY_SCHEMA).readonly()
100
+ });
101
+ // packages/contract/src/answer-view.ts
102
+ import { z as z4 } from "zod";
103
+ var ANSWER_VIEW_SCHEMA = z4.object({
104
+ answer: z4.string(),
105
+ at: z4.number(),
106
+ session: z4.string(),
107
+ name: z4.string().nullable(),
108
+ message: z4.string(),
109
+ text: z4.string(),
110
+ complete: z4.boolean()
111
+ });
112
+ // packages/contract/src/contract-version.ts
113
+ var CONTRACT_VERSION = "7.4.1";
114
+
115
+ // packages/contract/src/daemon-features.ts
116
+ var DAEMON_FEATURES = ["events.read.from-start"];
117
+
118
+ // packages/contract/src/check-daemon.ts
119
+ function checkDaemon(hello, contractVersion = CONTRACT_VERSION) {
120
+ const daemonMajor = parseMajor(hello.daemon.replace(/^atc\//u, ""));
121
+ const contractMajor = parseMajor(contractVersion);
122
+ if (contractMajor === null) {
123
+ throw new Error(`the contract's version ${contractVersion} names no major version`);
124
+ }
125
+ if (daemonMajor === null) {
126
+ return { verdict: "unreadable", daemon: hello.daemon };
127
+ }
128
+ if (daemonMajor !== contractMajor) {
129
+ return {
130
+ verdict: daemonMajor < contractMajor ? "older" : "newer",
131
+ daemonMajor,
132
+ contractMajor
133
+ };
134
+ }
135
+ const known = DAEMON_FEATURES;
136
+ return {
137
+ verdict: "match",
138
+ missing: DAEMON_FEATURES.filter((feature) => !hello.features.includes(feature)),
139
+ added: hello.features.filter((feature) => !known.includes(feature))
140
+ };
141
+ }
142
+ function parseMajor(version) {
143
+ const major = /^(?<major>\d+)\.\d+\.\d+/u.exec(version)?.groups?.["major"];
144
+ return major === undefined ? null : Number(major);
145
+ }
146
+ // packages/contract/src/commit-id-pattern.ts
147
+ var COMMIT_ID_PATTERN = /^(?:[\da-f]{40}|[\da-f]{64})$/u;
148
+ // packages/contract/src/config-file-schema.ts
149
+ import { z as z7 } from "zod";
150
+
151
+ // packages/contract/src/schema/build-optional-boolean.ts
152
+ import { z as z5 } from "zod";
153
+ function buildOptionalBoolean() {
154
+ return z5.preprocess((value) => typeof value === "boolean" ? value : undefined, z5.boolean().optional());
155
+ }
156
+
157
+ // packages/contract/src/schema/build-optional-string.ts
158
+ import { z as z6 } from "zod";
159
+ function buildOptionalString() {
160
+ return z6.preprocess((value) => typeof value === "string" ? value : undefined, z6.string().optional());
161
+ }
162
+
163
+ // packages/contract/src/config-file-schema.ts
164
+ var CONFIG_FILE_SCHEMA = z7.object({
165
+ agents: z7.unknown().optional(),
166
+ dirs: z7.unknown().optional(),
167
+ workspaces: z7.unknown().optional(),
168
+ authProfiles: z7.unknown().optional(),
169
+ hooks: z7.unknown().optional(),
170
+ leader: buildOptionalString(),
171
+ targets: z7.unknown().optional(),
172
+ defaultTarget: z7.unknown().optional(),
173
+ principals: z7.unknown().optional(),
174
+ daemons: z7.unknown().optional(),
175
+ restoreFleetOnRestart: buildOptionalBoolean()
176
+ });
177
+ // packages/contract/src/daemon-contract.ts
178
+ import { eventIterator, oc } from "@orpc/contract";
179
+ import { z as z37 } from "zod";
180
+
181
+ // packages/contract/src/daemon-error-map.ts
182
+ import { z as z8 } from "zod";
183
+
184
+ // packages/contract/src/light/error-codes.ts
185
+ var ERROR_CODES = [
186
+ "protocol_mismatch",
187
+ "unauthorized",
188
+ "unknown_method",
189
+ "bad_args",
190
+ "no_such_session",
191
+ "session_dead",
192
+ "permission_pending",
193
+ "menu_changed",
194
+ "menu_label_mismatch",
195
+ "menu_busy",
196
+ "unsupported",
197
+ "unsupported_operation",
198
+ "unknown_target",
199
+ "target_unavailable",
200
+ "target_changed",
201
+ "target_config_invalid",
202
+ "target_forbidden",
203
+ "not_a_git_repo",
204
+ "no_commits",
205
+ "unreadable_tree",
206
+ "has_submodules",
207
+ "lfs_unsupported",
208
+ "workspace_dirty",
209
+ "no_origin",
210
+ "invalid_git_url",
211
+ "git_transports_invalid",
212
+ "unpushed_head",
213
+ "credential_in_url",
214
+ "credential_missing",
215
+ "ref_not_found",
216
+ "clone_failed",
217
+ "git_output_open",
218
+ "sanitize_failed",
219
+ "tar_failed",
220
+ "workspace_exists",
221
+ "workspace_overlap",
222
+ "transfer_failed",
223
+ "workspace_mismatch",
224
+ "scope_invalid",
225
+ "github_unavailable",
226
+ "host_unavailable",
227
+ "auth_not_configured",
228
+ "auth_target_unsupported",
229
+ "auth_signin_needed",
230
+ "auth_token_scope",
231
+ "auth_token_too_broad",
232
+ "auth_host_out_of_scope",
233
+ "auth_secret_not_grantable",
234
+ "auth_secret_mismatch",
235
+ "auth_runtime_mismatch",
236
+ "auth_runtime_exists",
237
+ "auth_grant_missing",
238
+ "auth_grants_mismatch",
239
+ "auth_rebind_required",
240
+ "auth_blocked",
241
+ "auth_binding_mismatch",
242
+ "auth_binding_invalid",
243
+ "auth_revocation_pending",
244
+ "broker_not_ready",
245
+ "auth_placeholder_unsupported",
246
+ "host_leased",
247
+ "confirmation_required",
248
+ "confirm_token_invalid",
249
+ "session_pinned",
250
+ "session_live",
251
+ "already_answered",
252
+ "too_slow",
253
+ "stale_epoch",
254
+ "idempotency_conflict",
255
+ "outcome_unknown",
256
+ "idempotency_key_unknown",
257
+ "internal"
258
+ ];
259
+
260
+ // packages/contract/src/daemon-error-map.ts
261
+ var ERROR_DATA_SCHEMA = z8.record(z8.string(), z8.unknown()).optional();
262
+ var DAEMON_ERROR_MAP = buildErrorMap();
263
+ function buildErrorMap() {
264
+ const map = {};
265
+ for (const code of ERROR_CODES) {
266
+ map[code] = { data: ERROR_DATA_SCHEMA };
267
+ }
268
+ if (!hasEveryCode(map)) {
269
+ throw new Error("an error code has no entry in the error map");
270
+ }
271
+ return map;
272
+ }
273
+ function hasEveryCode(map) {
274
+ return ERROR_CODES.every((code) => Object.hasOwn(map, code));
275
+ }
276
+
277
+ // packages/contract/src/daemon-event.ts
278
+ import { z as z18 } from "zod";
279
+
280
+ // packages/contract/src/light/message-sender.ts
281
+ import { z as z9 } from "zod";
282
+ var MESSAGE_SENDER_SCHEMA = z9.discriminatedUnion("kind", [
283
+ z9.object({ kind: z9.literal("connector"), client: z9.string(), name: z9.string() }),
284
+ z9.object({ kind: z9.literal("session"), session: z9.string(), name: z9.string() }),
285
+ z9.object({ kind: z9.literal("local"), name: z9.string() }),
286
+ z9.object({ kind: z9.literal("owner"), name: z9.string() })
287
+ ]);
288
+
289
+ // packages/contract/src/message-status.ts
290
+ import { z as z10 } from "zod";
291
+ var MESSAGE_STATUS_SCHEMA = z10.enum(["queued", "delivered", "answered", "unanswered"]);
292
+
293
+ // packages/contract/src/restart-result.ts
294
+ import { z as z11 } from "zod";
295
+ var RESTART_FAILED_ROW_SCHEMA = z11.object({
296
+ name: z11.string(),
297
+ id: z11.string(),
298
+ reason: z11.string()
299
+ });
300
+ var RESTART_INTERRUPTED_ROW_SCHEMA = z11.object({ name: z11.string(), id: z11.string() });
301
+ var RESTART_RESULT_SCHEMA = z11.object({
302
+ runID: z11.string(),
303
+ code: z11.number().int(),
304
+ pid: z11.number().int().nullable(),
305
+ build: z11.string().nullable(),
306
+ listenPort: z11.number().int().nullable(),
307
+ restored: z11.number().int(),
308
+ total: z11.number().int(),
309
+ failed: z11.array(RESTART_FAILED_ROW_SCHEMA).readonly(),
310
+ interrupted: z11.array(RESTART_INTERRUPTED_ROW_SCHEMA).readonly(),
311
+ error: z11.string().nullable()
312
+ });
313
+
314
+ // packages/contract/src/session-descriptor.ts
315
+ import { z as z17 } from "zod";
316
+
317
+ // packages/contract/src/session-lifecycle.ts
318
+ import { z as z12 } from "zod";
319
+ var SESSION_LIFECYCLE_SCHEMA = z12.object({
320
+ desired: z12.enum(["run", "sleep", "stop"]),
321
+ vm: z12.enum(["none", "awake", "asleep", "unknown"]),
322
+ harness: z12.enum(["running", "suspended", "exited"]),
323
+ attachment: z12.enum(["local", "attached", "reattaching", "detached"])
324
+ });
325
+
326
+ // packages/contract/src/session-workspace.ts
327
+ import { z as z13 } from "zod";
328
+ var SESSION_WORKSPACE_SCHEMA = z13.object({
329
+ repoURL: z13.string(),
330
+ sha: z13.string(),
331
+ ref: z13.string().optional(),
332
+ materializedAt: z13.number()
333
+ });
334
+
335
+ // packages/contract/src/to-agent-session-id.ts
336
+ import { z as z14 } from "zod";
337
+ var AGENT_SESSION_ID_SCHEMA = z14.string().brand();
338
+ function toAgentSessionID(id) {
339
+ return AGENT_SESSION_ID_SCHEMA.parse(id);
340
+ }
341
+
342
+ // packages/contract/src/to-daemon-id.ts
343
+ import { z as z15 } from "zod";
344
+ var DAEMON_ID_SCHEMA = z15.string().brand();
345
+ function toDaemonID(id) {
346
+ return DAEMON_ID_SCHEMA.parse(id);
347
+ }
348
+
349
+ // packages/contract/src/to-session-id.ts
350
+ import { z as z16 } from "zod";
351
+ var SESSION_ID_SCHEMA = z16.string().brand();
352
+ function toSessionID(id) {
353
+ return SESSION_ID_SCHEMA.parse(id);
354
+ }
355
+
356
+ // packages/contract/src/session-descriptor.ts
357
+ var SESSION_DESCRIPTOR_SCHEMA = z17.object({
358
+ id: z17.string().transform((id) => toSessionID(id)),
359
+ name: z17.string(),
360
+ cwd: z17.string(),
361
+ state: z17.enum(["running", "needs_you", "done", "exited"]),
362
+ unread: z17.boolean(),
363
+ lastMsg: z17.string(),
364
+ lastDetail: z17.string().optional(),
365
+ restoreRefusal: z17.string().optional(),
366
+ agentSessionID: z17.string().transform((id) => toAgentSessionID(id)).optional(),
367
+ agent: z17.string(),
368
+ pinned: z17.boolean(),
369
+ lastAttachedAt: z17.number(),
370
+ repoRoot: z17.string(),
371
+ namedBy: z17.enum(["user", "auto", "agent"]),
372
+ createdAt: z17.number(),
373
+ kind: z17.enum(["pty", "headless"]),
374
+ alive: z17.boolean(),
375
+ canEject: z17.boolean(),
376
+ parent: z17.string().transform((id) => toSessionID(id)).optional(),
377
+ locator: z17.object({
378
+ daemonID: z17.string().transform((id) => toDaemonID(id)),
379
+ targetID: z17.string()
380
+ }),
381
+ workspace: SESSION_WORKSPACE_SCHEMA.optional(),
382
+ lifecycle: SESSION_LIFECYCLE_SCHEMA,
383
+ model: z17.string().optional(),
384
+ pluginDirs: z17.array(z17.string()).readonly().optional()
385
+ });
386
+
387
+ // packages/contract/src/daemon-event.ts
388
+ var SESSION_EVENT = z18.object({ session: SESSION_DESCRIPTOR_SCHEMA });
389
+ var DAEMON_EVENT_SCHEMA = z18.discriminatedUnion("ev", [
390
+ SESSION_EVENT.extend({ ev: z18.literal("SessionAdded") }),
391
+ SESSION_EVENT.extend({ ev: z18.literal("SessionState") }),
392
+ SESSION_EVENT.extend({ ev: z18.literal("SessionAttached") }),
393
+ SESSION_EVENT.extend({ ev: z18.literal("SessionDetached") }),
394
+ z18.object({
395
+ ev: z18.literal("SessionRenamed"),
396
+ sessionID: z18.string(),
397
+ name: z18.string(),
398
+ namedBy: z18.enum(["user", "auto", "agent"])
399
+ }),
400
+ z18.object({ ev: z18.literal("SessionRemoved"), sessionID: z18.string() }),
401
+ z18.object({
402
+ ev: z18.literal("SessionResized"),
403
+ sessionID: z18.string(),
404
+ cols: z18.number(),
405
+ rows: z18.number()
406
+ }),
407
+ z18.object({
408
+ ev: z18.literal("SessionOutput"),
409
+ sessionID: z18.string(),
410
+ seq: z18.number(),
411
+ data: z18.string()
412
+ }),
413
+ z18.object({ ev: z18.literal("SessionDesync"), sessionID: z18.string(), dropped: z18.number() }),
414
+ z18.object({
415
+ ev: z18.literal("PermissionRequested"),
416
+ request: z18.string(),
417
+ sessionID: z18.string(),
418
+ message: z18.string(),
419
+ respondable: z18.boolean()
420
+ }),
421
+ z18.object({ ev: z18.literal("PermissionResolved"), request: z18.string(), decision: z18.string() }),
422
+ z18.object({
423
+ ev: z18.literal("SessionMessage"),
424
+ sessionID: z18.string(),
425
+ message: z18.string(),
426
+ status: MESSAGE_STATUS_SCHEMA,
427
+ from: z18.string(),
428
+ sender: MESSAGE_SENDER_SCHEMA.optional(),
429
+ textPreview: z18.string(),
430
+ sentAt: z18.number(),
431
+ deliveredAt: z18.number().optional(),
432
+ answeredAt: z18.number().optional(),
433
+ answerPreview: z18.string().optional(),
434
+ unansweredAt: z18.number().optional(),
435
+ unansweredReason: z18.string().optional()
436
+ }),
437
+ z18.object({
438
+ ev: z18.literal("SessionNote"),
439
+ sessionID: z18.string(),
440
+ kind: z18.string(),
441
+ text: z18.string(),
442
+ sentAt: z18.number()
443
+ }),
444
+ z18.object({
445
+ ev: z18.literal("InboxMessage"),
446
+ sessionID: z18.string(),
447
+ message: z18.string(),
448
+ from: z18.string(),
449
+ sender: MESSAGE_SENDER_SCHEMA.optional(),
450
+ text: z18.string(),
451
+ sentAt: z18.number()
452
+ }),
453
+ z18.object({
454
+ ev: z18.literal("InboxNotice"),
455
+ sessionID: z18.string(),
456
+ message: z18.string(),
457
+ from: z18.string(),
458
+ status: z18.enum(["answered", "unanswered"]),
459
+ answer: z18.string().optional(),
460
+ reason: z18.string().optional(),
461
+ at: z18.number()
462
+ }),
463
+ z18.object({
464
+ ev: z18.literal("InboxClosed"),
465
+ sessionID: z18.string(),
466
+ reason: z18.enum(["replaced", "removed"])
467
+ }),
468
+ z18.object({ ev: z18.literal("DaemonRestarted"), result: RESTART_RESULT_SCHEMA })
469
+ ]);
470
+
471
+ // packages/contract/src/events-page.ts
472
+ import { z as z20 } from "zod";
473
+
474
+ // packages/contract/src/fleet-event.ts
475
+ import { z as z19 } from "zod";
476
+ var FLEET_EVENT_SCHEMA = z19.object({
477
+ cursor: z19.string(),
478
+ at: z19.number(),
479
+ session: z19.string(),
480
+ name: z19.string().nullable(),
481
+ kind: z19.string(),
482
+ detail: z19.string().nullable(),
483
+ message: z19.string().optional(),
484
+ label: z19.string().optional(),
485
+ result: RESTART_RESULT_SCHEMA.optional(),
486
+ origin: z19.object({ daemon: z19.string(), incarnation: z19.string(), cursor: z19.string() }).optional()
487
+ });
488
+
489
+ // packages/contract/src/events-page.ts
490
+ var EVENTS_PAGE_SCHEMA = z20.object({
491
+ events: z20.array(FLEET_EVENT_SCHEMA).readonly(),
492
+ cursor: z20.string(),
493
+ more: z20.boolean()
494
+ });
495
+
496
+ // packages/contract/src/fleet-entry-view.ts
497
+ import { z as z21 } from "zod";
498
+ var FLEET_ENTRY_VIEW_SCHEMA = z21.object({
499
+ sessionID: z21.string(),
500
+ name: z21.string(),
501
+ cwd: z21.string(),
502
+ agentSessionID: z21.string().optional(),
503
+ agent: z21.string(),
504
+ pinned: z21.boolean().optional(),
505
+ lastAttachedAt: z21.number().optional(),
506
+ exited: z21.boolean().optional(),
507
+ parent: z21.string().optional(),
508
+ prompt: z21.string().optional(),
509
+ result: z21.string().optional(),
510
+ transcriptPath: z21.string().optional(),
511
+ model: z21.string().optional(),
512
+ effort: z21.string().optional(),
513
+ pluginDirs: z21.array(z21.string()).readonly().optional(),
514
+ target: z21.string().optional(),
515
+ targetIdentity: z21.string().optional(),
516
+ workspace: SESSION_WORKSPACE_SCHEMA.optional(),
517
+ withheldEnv: z21.array(z21.string()).readonly().optional(),
518
+ desired: z21.enum(["sleep", "stop"]).optional(),
519
+ hostKey: z21.string().optional()
520
+ });
521
+
522
+ // packages/contract/src/git-probe-result.ts
523
+ import { z as z23 } from "zod";
524
+
525
+ // packages/contract/src/git-ref.ts
526
+ import { z as z22 } from "zod";
527
+ var GIT_REF_SCHEMA = z22.object({
528
+ name: z22.string(),
529
+ kind: z22.enum(["branch", "tag"]),
530
+ sha: z22.string()
531
+ });
532
+
533
+ // packages/contract/src/git-probe-result.ts
534
+ var GIT_PROBE_RESULT_SCHEMA = z23.object({
535
+ url: z23.string(),
536
+ head: z23.string().nullable(),
537
+ refs: z23.array(GIT_REF_SCHEMA).readonly(),
538
+ resolved: z23.object({ sha: z23.string(), branch: z23.string().nullable() }).nullable()
539
+ });
540
+
541
+ // packages/contract/src/hello-result.ts
542
+ import { z as z24 } from "zod";
543
+ var HELLO_RESULT_SCHEMA = z24.object({
544
+ daemon: z24.string(),
545
+ daemonID: z24.string(),
546
+ limits: z24.object({ maxLine: z24.number(), maxChunk: z24.number() }),
547
+ idempotency: z24.object({ completedRetentionMs: z24.number() }),
548
+ lastUsedAgent: z24.string(),
549
+ peerSession: z24.string().nullable(),
550
+ features: z24.array(z24.string()).readonly().default([])
551
+ });
552
+
553
+ // packages/contract/src/menu-view.ts
554
+ import { z as z25 } from "zod";
555
+ var MENU_VIEW_SCHEMA = z25.object({
556
+ text: z25.string(),
557
+ options: z25.array(buildMenuOptionSchema()).readonly(),
558
+ menuToken: z25.string()
559
+ });
560
+ function buildMenuOptionSchema() {
561
+ return z25.object({
562
+ option: z25.number(),
563
+ label: z25.string(),
564
+ checked: z25.boolean().nullable(),
565
+ highlighted: z25.boolean()
566
+ });
567
+ }
568
+
569
+ // packages/contract/src/message-answer.ts
570
+ import { z as z26 } from "zod";
571
+ var MESSAGE_ANSWER_SCHEMA = z26.object({
572
+ message: z26.string(),
573
+ status: MESSAGE_STATUS_SCHEMA
574
+ });
575
+
576
+ // packages/contract/src/message-view.ts
577
+ import { z as z27 } from "zod";
578
+ var MESSAGE_VIEW_SCHEMA = z27.object({
579
+ message: z27.string(),
580
+ session: z27.string(),
581
+ from: z27.string(),
582
+ sender: MESSAGE_SENDER_SCHEMA.optional(),
583
+ text: z27.string(),
584
+ status: MESSAGE_STATUS_SCHEMA,
585
+ sentAt: z27.number(),
586
+ deliveredAt: z27.number().optional(),
587
+ answeredAt: z27.number().optional(),
588
+ answer: z27.string().optional(),
589
+ unansweredAt: z27.number().optional(),
590
+ unansweredReason: z27.string().optional(),
591
+ turn: z27.string().nullable(),
592
+ answeredWith: z27.array(z27.string()).readonly()
593
+ });
594
+
595
+ // packages/contract/src/note-view.ts
596
+ import { z as z28 } from "zod";
597
+ var NOTE_VIEW_SCHEMA = z28.object({
598
+ note: z28.string(),
599
+ at: z28.number(),
600
+ session: z28.string(),
601
+ name: z28.string().nullable(),
602
+ label: z28.string(),
603
+ text: z28.string(),
604
+ complete: z28.boolean()
605
+ });
606
+
607
+ // packages/contract/src/published-record-schema.ts
608
+ import { z as z29 } from "zod";
609
+ var WORKSPACE_SCOPE_SCHEMA = z29.object({
610
+ path: z29.string(),
611
+ branch: z29.string().nullable(),
612
+ repoURL: z29.string().nullable(),
613
+ sha: z29.string().nullable()
614
+ });
615
+ var WORKTREE_SCOPE_SCHEMA = z29.object({ path: z29.string(), branch: z29.string().nullable() });
616
+ var BRANCH_SCOPE_SCHEMA = z29.object({ name: z29.string(), repo: z29.string() });
617
+ var PULL_REQUEST_SCOPE_SCHEMA = z29.object({
618
+ repo: z29.string(),
619
+ number: z29.number(),
620
+ url: z29.string(),
621
+ branch: z29.string()
622
+ });
623
+ var SCOPE_SCHEMA = z29.object({
624
+ workspace: WORKSPACE_SCOPE_SCHEMA,
625
+ worktrees: z29.array(WORKTREE_SCOPE_SCHEMA),
626
+ branches: z29.array(BRANCH_SCOPE_SCHEMA),
627
+ pullRequests: z29.array(PULL_REQUEST_SCOPE_SCHEMA)
628
+ });
629
+ var PUBLISHED_RECORD_SCHEMA = z29.object({
630
+ format: z29.literal("atc.session-record"),
631
+ version: z29.literal(1),
632
+ session: z29.string(),
633
+ daemonID: z29.string(),
634
+ target: z29.string(),
635
+ revision: z29.number().int().min(1),
636
+ updatedAt: z29.string(),
637
+ name: z29.string().nullable(),
638
+ transcriptPath: z29.string().nullable(),
639
+ scope: SCOPE_SCHEMA
640
+ });
641
+
642
+ // packages/contract/src/request-param-schemas.ts
643
+ import { z as z31 } from "zod";
644
+
645
+ // packages/contract/src/to-message-id.ts
646
+ import { z as z30 } from "zod";
647
+ var MESSAGE_ID_SCHEMA = z30.string().brand();
648
+ function toMessageID(id) {
649
+ return MESSAGE_ID_SCHEMA.parse(id);
650
+ }
651
+
652
+ // packages/contract/src/request-param-schemas.ts
653
+ var EJECT_DEFAULT_PROMPT = "Continue the task autonomously. Verify your work as you go and stop when it is complete.";
654
+ var SESSION_DEFAULTED = z31.object({
655
+ session: buildDefaultedString("").transform(toSessionID)
656
+ });
657
+ var IDEMPOTENCY_KEY = z31.string({ error: "idempotencyKey must be a string" }).min(1, "idempotencyKey must not be empty").max(200, "idempotencyKey must be at most 200 characters").optional();
658
+ var REPLAY_ONLY = z31.boolean({ error: "replayOnly must be a boolean" }).optional();
659
+ var CREDENTIAL_REF = z31.strictObject({
660
+ kind: z31.literal("env"),
661
+ name: z31.string().regex(/^[A-Za-z_]\w*$/u, "a credentialRef names an environment variable")
662
+ });
663
+ var GIT_URL = z31.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 -");
664
+ var GIT_REF = z31.string().min(1, "a git workspace ref must not be empty").refine((ref) => !ref.startsWith("-"), "a git workspace ref must not start with -");
665
+ var GIT_SHA = z31.string().regex(COMMIT_ID_PATTERN, "a git workspace sha is a full commit id");
666
+ var WORKSPACE_SOURCE = z31.discriminatedUnion("kind", [
667
+ z31.strictObject({
668
+ kind: z31.literal("path"),
669
+ path: z31.string({ error: "a path workspace requires an absolute path" }).startsWith("/", "a path workspace requires an absolute path"),
670
+ allowDirty: z31.enum(["refuse", "warn"]).optional()
671
+ }),
672
+ z31.strictObject({
673
+ kind: z31.literal("git"),
674
+ url: GIT_URL,
675
+ ref: GIT_REF.optional(),
676
+ sha: GIT_SHA.optional(),
677
+ credentialRef: CREDENTIAL_REF.optional()
678
+ }).refine((source) => source.ref !== undefined || source.sha !== undefined, {
679
+ message: "a git workspace takes a ref, a sha, or both"
680
+ })
681
+ ]);
682
+ var TARGET = z31.string({ error: "target must be a non-empty target id" }).min(1, "target must be a non-empty target id").optional();
683
+ var SOURCE_ID = z31.string({ error: "source must be a source id" }).min(1, "source must be a source id").max(64, "source must be a source id");
684
+ var SOURCE_TEXT = z31.string({ error: "source text must be a string" }).max(4096, "source text must be at most 4096 characters");
685
+ var CLIENT_CWD = z31.string({ error: "clientCwd must be an absolute path" }).startsWith("/", "clientCwd must be an absolute path").max(4096, "clientCwd must be at most 4096 characters");
686
+ var TERMINAL_SIZE_ERROR = "cols and rows must be whole numbers from 1 to 4096";
687
+ var REQUEST_PARAM_SCHEMAS = {
688
+ "daemon.hello": z31.object({
689
+ client: buildDefaultedString("unknown client"),
690
+ protocol: z31.number({ error: "daemon.hello protocol must be a number" }).optional(),
691
+ principal: z31.string({ error: "daemon.hello principal must be a non-empty string" }).min(1, "daemon.hello principal must be a non-empty string").optional(),
692
+ session: z31.preprocess((input) => typeof input === "string" && input !== "" ? input : undefined, z31.string().transform(toSessionID).optional())
693
+ }),
694
+ "daemon.ping": z31.object({}),
695
+ "daemon.quit": z31.object({}),
696
+ "daemon.backup": z31.object({
697
+ path: z31.string({ error: "daemon.backup path must be an absolute path" }).refine((path) => path.startsWith("/"), "daemon.backup path must be an absolute path")
698
+ }),
699
+ "daemon.restarted": z31.object({ result: RESTART_RESULT_SCHEMA }),
700
+ "session.list": z31.object({}),
701
+ "dirs.list": z31.object({}),
702
+ "agents.list": z31.object({}),
703
+ "sources.list": z31.object({
704
+ source: SOURCE_ID,
705
+ target: TARGET,
706
+ scope: SOURCE_TEXT.min(1, "scope must be non-empty").optional(),
707
+ text: SOURCE_TEXT.optional()
708
+ }),
709
+ "sources.interpret": z31.object({
710
+ source: SOURCE_ID,
711
+ input: SOURCE_TEXT,
712
+ target: TARGET,
713
+ clientCwd: CLIENT_CWD.optional()
714
+ }),
715
+ "sources.complete": z31.object({
716
+ source: SOURCE_ID,
717
+ input: SOURCE_TEXT,
718
+ target: TARGET,
719
+ clientCwd: CLIENT_CWD.optional()
720
+ }),
721
+ "git.probe": z31.object({
722
+ url: GIT_URL,
723
+ ref: GIT_REF.optional(),
724
+ sha: GIT_SHA.optional(),
725
+ credentialRef: CREDENTIAL_REF.optional(),
726
+ target: TARGET
727
+ }).refine((probe) => probe.ref === undefined || probe.sha === undefined, {
728
+ message: "git.probe takes at most one of ref or sha"
729
+ }),
730
+ "fleet.list": z31.object({}),
731
+ "fleet.restore": z31.object({
732
+ cols: buildTerminalSize(80),
733
+ rows: buildTerminalSize(24)
734
+ }),
735
+ "session.spawn": z31.object({
736
+ cwd: z31.string({ error: "session.spawn requires a cwd" }).min(1, "session.spawn requires a cwd").optional(),
737
+ name: buildDefaultedString(""),
738
+ prompt: buildDefaultedString(""),
739
+ cols: buildTerminalSize(80),
740
+ rows: buildTerminalSize(24),
741
+ resume: buildDefaultedBooleanOrString(false).transform((value) => typeof value === "string" ? toAgentSessionID(value) : value),
742
+ agent: z31.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(),
743
+ model: z31.string({ error: "session.spawn model must be a string" }).optional(),
744
+ effort: z31.string({ error: "session.spawn effort must be a string" }).optional(),
745
+ pluginDirs: z31.array(z31.string({ error: "session.spawn pluginDirs must be an array of strings" }), {
746
+ error: "session.spawn pluginDirs must be an array of strings"
747
+ }).max(32, "session.spawn pluginDirs takes at most 32 folders").optional(),
748
+ idempotencyKey: IDEMPOTENCY_KEY,
749
+ replayOnly: REPLAY_ONLY,
750
+ target: z31.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(),
751
+ workspace: WORKSPACE_SOURCE.optional(),
752
+ trustClonedWorkspace: z31.boolean({ error: "session.spawn trustClonedWorkspace must be a boolean" }).optional(),
753
+ scope: z31.unknown().optional(),
754
+ parent: z31.preprocess((input) => typeof input === "string" && input !== "" ? input : undefined, z31.string().transform(toSessionID).optional())
755
+ }),
756
+ "session.kill": SESSION_DEFAULTED.extend({
757
+ stopOnly: z31.boolean({ error: "session.kill stopOnly must be a boolean" }).optional()
758
+ }),
759
+ "session.ack": SESSION_DEFAULTED,
760
+ "session.forget": SESSION_DEFAULTED.extend({
761
+ confirmToken: z31.string({ error: "session.forget confirmToken must be a string" }).min(1, "session.forget confirmToken must not be empty").optional(),
762
+ refusePinned: z31.boolean({ error: "session.forget refusePinned must be a boolean" }).optional(),
763
+ refuseLive: z31.boolean({ error: "session.forget refuseLive must be a boolean" }).optional()
764
+ }),
765
+ "session.auth.revoke": SESSION_DEFAULTED,
766
+ "session.auth.rebind": SESSION_DEFAULTED,
767
+ "session.scope.add": SESSION_DEFAULTED.extend({ scope: z31.unknown() }),
768
+ "session.update": SESSION_DEFAULTED.extend({
769
+ name: buildOptionalString(),
770
+ pinned: buildOptionalBoolean(),
771
+ parent: z31.null({ error: "session.update parent must be null" }).optional()
772
+ }),
773
+ "session.attach": SESSION_DEFAULTED.extend({
774
+ cols: buildTerminalSize(80),
775
+ rows: buildTerminalSize(24)
776
+ }),
777
+ "session.detach": SESSION_DEFAULTED,
778
+ "session.watch": SESSION_DEFAULTED,
779
+ "session.input": SESSION_DEFAULTED.extend({
780
+ data: buildDefaultedString("")
781
+ }),
782
+ "session.submit": SESSION_DEFAULTED.extend({
783
+ text: buildDefaultedString("")
784
+ }),
785
+ "session.resize": SESSION_DEFAULTED.extend({
786
+ cols: buildTerminalSize(0),
787
+ rows: buildTerminalSize(0)
788
+ }).refine((params) => params.cols >= 1 && params.rows >= 1, {
789
+ message: "session.resize requires positive cols and rows"
790
+ }),
791
+ "session.resumeCommand": SESSION_DEFAULTED,
792
+ "session.screen": SESSION_DEFAULTED,
793
+ "session.menu": SESSION_DEFAULTED,
794
+ "session.choose": SESSION_DEFAULTED.extend({
795
+ menuToken: z31.string({ error: "session.choose requires the menuToken of the menu it answers" }).min(1, "session.choose requires the menuToken of the menu it answers"),
796
+ option: z31.number({ error: "option must be a number" }).int("option must be a whole number").min(1, "option counts from 1").optional(),
797
+ label: z31.string({ error: "label must be a string" }).optional(),
798
+ key: z31.literal("escape", { error: "key takes only 'escape'" }).optional()
799
+ }).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" }),
800
+ "session.eject": SESSION_DEFAULTED.extend({
801
+ prompt: buildDefaultedNonEmptyString(EJECT_DEFAULT_PROMPT)
802
+ }),
803
+ "session.adopt": SESSION_DEFAULTED.extend({
804
+ cols: buildTerminalSize(80),
805
+ rows: buildTerminalSize(24)
806
+ }),
807
+ "permission.respond": z31.object({
808
+ request: buildDefaultedString(""),
809
+ decision: buildDefaultedString("")
810
+ }).refine((params) => params.request !== "" && params.decision !== "", {
811
+ message: "permission.respond requires a request and a decision"
812
+ }),
813
+ "session.get": SESSION_DEFAULTED,
814
+ "session.read": SESSION_DEFAULTED.extend({
815
+ cursor: buildOptionalCursor(),
816
+ limit: buildDefaultedNumber(50).transform((value) => Math.min(Math.max(Math.trunc(value), 1), 200))
817
+ }),
818
+ "events.read": z31.object({
819
+ cursor: buildOptionalCursor(),
820
+ from: z31.literal("start", { error: "events.read takes from only as 'start'" }).optional(),
821
+ limit: buildDefaultedNumber(50).transform((value) => Math.min(Math.max(Math.trunc(value), 1), 200)),
822
+ waitMs: buildDefaultedWait(),
823
+ session: z31.preprocess((input) => typeof input === "string" && input !== "" ? input : undefined, z31.string().transform(toSessionID).optional())
824
+ }).refine((params) => params.cursor === undefined || params.from === undefined, {
825
+ message: "events.read takes a cursor or from, not both"
826
+ }),
827
+ "session.message": SESSION_DEFAULTED.extend({
828
+ text: buildDefaultedString(""),
829
+ idempotencyKey: IDEMPOTENCY_KEY,
830
+ replayOnly: REPLAY_ONLY,
831
+ from: z31.preprocess((input) => typeof input === "string" && input.trim() !== "" ? input.trim() : undefined, z31.string().max(200, "from must be at most 200 characters").optional()),
832
+ notice: z31.boolean({ error: "notice must be a boolean" }).optional()
833
+ }).refine((params) => params.text !== "", { message: "session.message requires text" }),
834
+ "session.tap": SESSION_DEFAULTED.extend({
835
+ notices: z31.boolean().default(false)
836
+ }),
837
+ "message.get": z31.object({
838
+ message: buildDefaultedString("").transform(toMessageID),
839
+ waitMs: buildDefaultedWait()
840
+ }).refine((params) => params.message !== "", { message: "message.get requires a message" }),
841
+ "note.get": z31.object({
842
+ note: buildDefaultedString("")
843
+ }).refine((params) => params.note !== "", { message: "note.get requires a note" }),
844
+ "answer.get": z31.object({
845
+ answer: buildDefaultedString("")
846
+ }).refine((params) => params.answer !== "", { message: "answer.get requires an answer" }),
847
+ "message.ack": SESSION_DEFAULTED.extend({
848
+ message: buildDefaultedString("").transform(toMessageID)
849
+ }).refine((params) => params.message !== "", { message: "message.ack requires a message" }),
850
+ "notice.ack": SESSION_DEFAULTED.extend({
851
+ message: buildDefaultedString("").transform(toMessageID)
852
+ }).refine((params) => params.message !== "", { message: "notice.ack requires a message" })
853
+ };
854
+ function buildDefaultedString(fallback) {
855
+ return z31.preprocess((input) => typeof input === "string" ? input : undefined, z31.string().default(fallback));
856
+ }
857
+ function buildTerminalSize(fallback) {
858
+ return z31.preprocess((input) => typeof input === "number" ? input : undefined, z31.number({ error: TERMINAL_SIZE_ERROR }).int(TERMINAL_SIZE_ERROR).min(1, TERMINAL_SIZE_ERROR).max(4096, TERMINAL_SIZE_ERROR).default(fallback));
859
+ }
860
+ function buildDefaultedBooleanOrString(fallback) {
861
+ return z31.preprocess((input) => typeof input === "boolean" || typeof input === "string" ? input : undefined, z31.union([z31.boolean(), z31.string()]).default(fallback));
862
+ }
863
+ function buildDefaultedNonEmptyString(fallback) {
864
+ return z31.preprocess((input) => typeof input === "string" && input !== "" ? input : undefined, z31.string().default(fallback));
865
+ }
866
+ function buildOptionalCursor() {
867
+ return z31.preprocess((input) => typeof input === "string" && input !== "" ? input : undefined, z31.string().optional());
868
+ }
869
+ function buildDefaultedNumber(fallback) {
870
+ return z31.preprocess((input) => typeof input === "number" ? input : undefined, z31.number().default(fallback));
871
+ }
872
+ function buildDefaultedWait() {
873
+ return buildDefaultedNumber(0).transform((value) => Math.min(Math.max(Math.trunc(value), 0), 30000));
874
+ }
875
+
876
+ // packages/contract/src/source-candidate.ts
877
+ import { z as z33 } from "zod";
878
+
879
+ // packages/contract/src/source-pick.ts
880
+ import { z as z32 } from "zod";
881
+ var SOURCE_PICK_SCHEMA = z32.discriminatedUnion("kind", [
882
+ z32.object({ kind: z32.literal("path"), directory: z32.string() }),
883
+ z32.object({ kind: z32.literal("git"), url: z32.string() })
884
+ ]);
885
+
886
+ // packages/contract/src/source-candidate.ts
887
+ var SOURCE_CANDIDATE_SCHEMA = z33.object({
888
+ label: z33.string(),
889
+ detail: z33.string().optional(),
890
+ pick: SOURCE_PICK_SCHEMA
891
+ });
892
+
893
+ // packages/contract/src/source-interpretation.ts
894
+ import { z as z34 } from "zod";
895
+ var SOURCE_INTERPRETATION_SCHEMA = z34.union([
896
+ z34.object({ kind: z34.literal("browse"), scope: z34.string() }),
897
+ SOURCE_PICK_SCHEMA,
898
+ z34.object({ kind: z34.literal("none") })
899
+ ]);
900
+
901
+ // packages/contract/src/spawn-answer.ts
902
+ import { z as z35 } from "zod";
903
+ var SPAWN_ANSWER_SCHEMA = z35.object({
904
+ session: SESSION_DESCRIPTOR_SCHEMA,
905
+ warnings: z35.array(z35.string()).readonly().optional()
906
+ });
907
+
908
+ // packages/contract/src/transcript-row.ts
909
+ import { z as z36 } from "zod";
910
+ var TRANSCRIPT_TOOL_SCHEMA = z36.object({ name: z36.string(), input: z36.string() });
911
+ var TRANSCRIPT_ROW_SCHEMA = z36.object({
912
+ role: z36.enum(["user", "assistant"]),
913
+ text: z36.string(),
914
+ tools: z36.array(TRANSCRIPT_TOOL_SCHEMA).readonly(),
915
+ at: z36.number().nullable()
916
+ });
917
+
918
+ // packages/contract/src/daemon-contract.ts
919
+ var EMPTY = z37.object({});
920
+ var STRINGS = z37.array(z37.string()).readonly();
921
+ var FORGET_CONFIRM = z37.object({ confirmToken: z37.string(), expiresAt: z37.number() });
922
+ var FORGET_DONE = z37.object({ forgotten: z37.literal(true), destroyed: z37.boolean() });
923
+ var PENDING_PROMPT = z37.object({ message: z37.string() });
924
+ var ACT = { access: "principal", readOnly: false, keyed: false };
925
+ var READ = { access: "principal", readOnly: true, keyed: false };
926
+ var KEYED = { access: "principal", readOnly: false, keyed: true };
927
+ var OWNER = { access: "owner", readOnly: false, keyed: false };
928
+ var base = oc.$meta(ACT).errors(DAEMON_ERROR_MAP);
929
+ var PARAMS = REQUEST_PARAM_SCHEMAS;
930
+ var DAEMON_CONTRACT = {
931
+ daemon: {
932
+ hello: base.meta(READ).input(PARAMS["daemon.hello"]).output(HELLO_RESULT_SCHEMA),
933
+ ping: base.meta(READ).input(PARAMS["daemon.ping"]).output(EMPTY),
934
+ quit: base.meta(OWNER).input(PARAMS["daemon.quit"]).output(EMPTY),
935
+ restarted: base.meta(OWNER).input(PARAMS["daemon.restarted"]).output(EMPTY),
936
+ backup: base.meta(OWNER).input(PARAMS["daemon.backup"]).output(z37.object({ path: z37.string(), bytes: z37.number() }))
937
+ },
938
+ dirs: {
939
+ list: base.meta(READ).input(PARAMS["dirs.list"]).output(z37.object({ dirs: STRINGS }))
940
+ },
941
+ agents: {
942
+ list: base.meta(READ).input(PARAMS["agents.list"]).output(AGENT_LIST_SCHEMA)
943
+ },
944
+ sources: {
945
+ list: base.meta(READ).input(PARAMS["sources.list"]).output(z37.object({
946
+ source: z37.string(),
947
+ scope: z37.string().nullable(),
948
+ candidates: z37.array(SOURCE_CANDIDATE_SCHEMA).readonly()
949
+ })),
950
+ interpret: base.meta(READ).input(PARAMS["sources.interpret"]).output(SOURCE_INTERPRETATION_SCHEMA),
951
+ complete: base.meta(READ).input(PARAMS["sources.complete"]).output(z37.object({ completions: z37.array(SOURCE_CANDIDATE_SCHEMA).readonly() }))
952
+ },
953
+ git: {
954
+ probe: base.meta(READ).input(PARAMS["git.probe"]).output(GIT_PROBE_RESULT_SCHEMA)
955
+ },
956
+ fleet: {
957
+ list: base.meta(READ).input(PARAMS["fleet.list"]).output(z37.object({ fleet: z37.array(FLEET_ENTRY_VIEW_SCHEMA).readonly() })),
958
+ restore: base.meta(OWNER).input(PARAMS["fleet.restore"]).output(z37.object({ restored: z37.number() }))
959
+ },
960
+ session: {
961
+ list: base.meta(READ).input(PARAMS["session.list"]).output(z37.object({ sessions: z37.array(SESSION_DESCRIPTOR_SCHEMA).readonly() })),
962
+ spawn: base.meta(KEYED).input(PARAMS["session.spawn"]).output(SPAWN_ANSWER_SCHEMA),
963
+ kill: base.input(PARAMS["session.kill"]).output(z37.object({ stopped: z37.boolean().optional() })),
964
+ ack: base.input(PARAMS["session.ack"]).output(EMPTY),
965
+ forget: base.input(PARAMS["session.forget"]).output(z37.union([FORGET_CONFIRM, FORGET_DONE])),
966
+ resumeCommand: base.meta(READ).input(PARAMS["session.resumeCommand"]).output(z37.object({ command: z37.string() })),
967
+ auth: {
968
+ revoke: base.meta(OWNER).input(PARAMS["session.auth.revoke"]).output(z37.object({ revoked: z37.literal(true) })),
969
+ rebind: base.meta(OWNER).input(PARAMS["session.auth.rebind"]).output(z37.object({ revision: z37.number(), restartPending: STRINGS }))
970
+ },
971
+ update: base.input(PARAMS["session.update"]).output(z37.object({ renameSkipped: z37.string().optional() })),
972
+ scope: {
973
+ add: base.input(PARAMS["session.scope.add"]).output(z37.object({ record: PUBLISHED_RECORD_SCHEMA }))
974
+ },
975
+ attach: base.input(PARAMS["session.attach"]).output(z37.object({ cols: z37.number(), rows: z37.number() })),
976
+ detach: base.input(PARAMS["session.detach"]).output(EMPTY),
977
+ watch: base.meta(READ).input(PARAMS["session.watch"]).output(z37.object({ cols: z37.number(), rows: z37.number(), seq: z37.number(), replay: z37.string() })),
978
+ input: base.input(PARAMS["session.input"]).output(EMPTY),
979
+ submit: base.input(PARAMS["session.submit"]).output(EMPTY),
980
+ resize: base.input(PARAMS["session.resize"]).output(EMPTY),
981
+ screen: base.meta(READ).input(PARAMS["session.screen"]).output(z37.object({ text: z37.string(), cols: z37.number(), rows: z37.number() })),
982
+ menu: base.meta(READ).input(PARAMS["session.menu"]).output(z37.object({ menu: MENU_VIEW_SCHEMA.nullable() })),
983
+ choose: base.input(PARAMS["session.choose"]).output(z37.object({
984
+ pressed: z37.string(),
985
+ menu: MENU_VIEW_SCHEMA.nullable(),
986
+ partial: z37.literal(true).optional()
987
+ })),
988
+ eject: base.input(PARAMS["session.eject"]).output(EMPTY),
989
+ adopt: base.input(PARAMS["session.adopt"]).output(EMPTY),
990
+ get: base.meta(READ).input(PARAMS["session.get"]).output(z37.object({
991
+ session: SESSION_DESCRIPTOR_SCHEMA,
992
+ prompt: z37.string().nullable(),
993
+ lastActivityAt: z37.number(),
994
+ pending: PENDING_PROMPT.nullable(),
995
+ result: z37.string().nullable(),
996
+ sessionRecord: PUBLISHED_RECORD_SCHEMA.nullable()
997
+ })),
998
+ read: base.meta(READ).input(PARAMS["session.read"]).output(z37.object({
999
+ rows: z37.array(TRANSCRIPT_ROW_SCHEMA).readonly(),
1000
+ cursor: z37.string(),
1001
+ more: z37.boolean()
1002
+ })),
1003
+ message: base.meta(KEYED).input(PARAMS["session.message"]).output(MESSAGE_ANSWER_SCHEMA),
1004
+ tap: base.input(PARAMS["session.tap"]).output(EMPTY)
1005
+ },
1006
+ permission: {
1007
+ respond: base.input(PARAMS["permission.respond"]).output(EMPTY)
1008
+ },
1009
+ events: {
1010
+ read: base.meta(READ).input(PARAMS["events.read"]).output(EVENTS_PAGE_SCHEMA),
1011
+ subscribe: base.meta(READ).input(EMPTY).output(eventIterator(DAEMON_EVENT_SCHEMA))
1012
+ },
1013
+ message: {
1014
+ get: base.meta(READ).input(PARAMS["message.get"]).output(MESSAGE_VIEW_SCHEMA),
1015
+ ack: base.input(PARAMS["message.ack"]).output(MESSAGE_ANSWER_SCHEMA)
1016
+ },
1017
+ notice: {
1018
+ ack: base.input(PARAMS["notice.ack"]).output(MESSAGE_ANSWER_SCHEMA)
1019
+ },
1020
+ note: {
1021
+ get: base.meta(READ).input(PARAMS["note.get"]).output(NOTE_VIEW_SCHEMA)
1022
+ },
1023
+ answer: {
1024
+ get: base.meta(READ).input(PARAMS["answer.get"]).output(ANSWER_VIEW_SCHEMA)
1025
+ }
1026
+ };
1027
+ // packages/contract/src/light/resolve-atc-paths.ts
1028
+ import { join as join2 } from "node:path";
1029
+
1030
+ // packages/contract/src/light/resolve-home-dir.ts
1031
+ import { homedir } from "node:os";
1032
+ function resolveHomeDir(env = process.env) {
1033
+ const home = env["HOME"];
1034
+ return home !== undefined && home !== "" ? home : homedir();
1035
+ }
1036
+
1037
+ // packages/contract/src/light/resolve-state-dir.ts
1038
+ import { join } from "node:path";
1039
+ function resolveStateDir(home) {
1040
+ return join(home, ".local", "state", "atc");
1041
+ }
1042
+
1043
+ // packages/contract/src/light/resolve-atc-paths.ts
1044
+ function resolveAtcPaths(env) {
1045
+ const home = resolveHomeDir(env);
1046
+ const stateDir = resolveStateDir(home);
1047
+ const runtimeDir = env["XDG_RUNTIME_DIR"] ?? stateDir;
1048
+ return {
1049
+ configFile: join2(home, ".config", "atc", "config.json"),
1050
+ stateDir,
1051
+ socketPath: join2(runtimeDir, "atc.sock"),
1052
+ daemonSocketPath: join2(runtimeDir, "atc-daemon.sock"),
1053
+ eventsSocketPath: join2(runtimeDir, "atc-events.sock"),
1054
+ daemonPidFile: join2(runtimeDir, "atc-daemon.pid"),
1055
+ daemonRecordFile: join2(stateDir, "daemon.json"),
1056
+ statusFile: join2(stateDir, "status.json")
1057
+ };
1058
+ }
1059
+ // packages/contract/src/light/session-env-names.ts
1060
+ var SESSION_ENV_NAMES = {
1061
+ sessionID: "ATC_SESSION_ID",
1062
+ socket: "ATC_SOCKET",
1063
+ bridge: "ATC_BRIDGE",
1064
+ outbox: "ATC_OUTBOX",
1065
+ sessionRecord: "ATC_SESSION_RECORD"
1066
+ };
1067
+ // packages/contract/src/procedure-meta.ts
1068
+ import { z as z38 } from "zod";
1069
+ var PROCEDURE_META_SCHEMA = z38.object({
1070
+ access: z38.enum(["owner", "principal"]),
1071
+ readOnly: z38.boolean(),
1072
+ keyed: z38.boolean()
1073
+ });
1074
+ export {
1075
+ AGENT_ENTRY_SCHEMA,
1076
+ AGENT_LIST_SCHEMA,
1077
+ ANSWER_VIEW_SCHEMA,
1078
+ COMMIT_ID_PATTERN,
1079
+ CONFIG_FILE_SCHEMA,
1080
+ CONTRACT_VERSION,
1081
+ DAEMON_CONTRACT,
1082
+ DAEMON_ERROR_MAP,
1083
+ DAEMON_EVENT_SCHEMA,
1084
+ DAEMON_FEATURES,
1085
+ ERROR_CODES,
1086
+ EVENTS_PAGE_SCHEMA,
1087
+ FLEET_ENTRY_VIEW_SCHEMA,
1088
+ FLEET_EVENT_SCHEMA,
1089
+ GIT_PROBE_RESULT_SCHEMA,
1090
+ GIT_REF_SCHEMA,
1091
+ HELLO_RESULT_SCHEMA,
1092
+ MENU_VIEW_SCHEMA,
1093
+ MESSAGE_ANSWER_SCHEMA,
1094
+ MESSAGE_SENDER_SCHEMA,
1095
+ MESSAGE_STATUS_SCHEMA,
1096
+ MESSAGE_VIEW_SCHEMA,
1097
+ NOTE_VIEW_SCHEMA,
1098
+ PROCEDURE_META_SCHEMA,
1099
+ PUBLISHED_RECORD_SCHEMA,
1100
+ REQUEST_PARAM_SCHEMAS,
1101
+ RESTART_RESULT_SCHEMA,
1102
+ SESSION_DESCRIPTOR_SCHEMA,
1103
+ SESSION_ENV_NAMES,
1104
+ SESSION_LIFECYCLE_SCHEMA,
1105
+ SESSION_WORKSPACE_SCHEMA,
1106
+ SOURCE_CANDIDATE_SCHEMA,
1107
+ SOURCE_ENTRY_SCHEMA,
1108
+ SOURCE_INTERPRETATION_SCHEMA,
1109
+ SOURCE_PICK_SCHEMA,
1110
+ SPAWN_ANSWER_SCHEMA,
1111
+ SPAWN_OPTION_SPEC_SCHEMA,
1112
+ TRANSCRIPT_ROW_SCHEMA,
1113
+ checkDaemon,
1114
+ resolveAtcPaths,
1115
+ resolveHomeDir,
1116
+ resolveStateDir,
1117
+ toAgentSessionID,
1118
+ toDaemonID,
1119
+ toMessageID,
1120
+ toSessionID
1121
+ };