@agentsky/sky 3.41.0 → 3.43.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.
@@ -1,1281 +0,0 @@
1
- import {
2
- ApiError,
3
- uploadLargeFile
4
- } from "./chunk-GSRLZKDU.js";
5
- import {
6
- SessionSourceCollector,
7
- USER_AGENT,
8
- UnsafeImportError,
9
- publicRemote,
10
- redactLine,
11
- redactTraceText
12
- } from "./chunk-RX2J4TS6.js";
13
- import {
14
- apiBase,
15
- apiToken
16
- } from "./chunk-XHZJG3QT.js";
17
- import "./chunk-MLKGABMK.js";
18
-
19
- // src/trace-library.ts
20
- import { createHash as createHash3 } from "crypto";
21
- import { createReadStream as createReadStream3, existsSync as existsSync4, mkdirSync as mkdirSync3, mkdtempSync, readdirSync as readdirSync2, readFileSync as readFileSync2, rmSync as rmSync3, statSync as statSync3, writeFileSync as writeFileSync2 } from "fs";
22
- import { createInterface } from "readline";
23
- import { homedir as homedir2, hostname } from "os";
24
- import { basename as basename3, dirname as dirname4, join as join3, sep } from "path";
25
- import { fileURLToPath, pathToFileURL } from "url";
26
- import { createGunzip as createGunzip2 } from "zlib";
27
-
28
- // src/trace-source.ts
29
- import { createHash } from "crypto";
30
- import { createReadStream, createWriteStream, closeSync, existsSync, fsyncSync, mkdirSync, openSync, realpathSync, renameSync, rmSync, statSync } from "fs";
31
- import { once } from "events";
32
- import { basename, dirname, join, resolve } from "path";
33
- import { createGunzip } from "zlib";
34
- var SOURCE_CAPTURE_VERSION = 2;
35
- function canonicalSourceApiBase(value) {
36
- const url = new URL(value);
37
- url.username = "";
38
- url.password = "";
39
- url.search = "";
40
- url.hash = "";
41
- return url.toString().replace(/\/$/, "");
42
- }
43
- async function captureTraceSource(session, directory, context) {
44
- const originals = session.trace?.source_files;
45
- const files = originals?.length ? originals : session.files;
46
- for (const file of files) {
47
- const allowed = session.files.some((collected) => resolve(file) === resolve(collected) || resolve(file) === resolve(collected.replace(/\.json$/, ".source.jsonl")) && dirname(realpathSync(file)) === dirname(realpathSync(collected)));
48
- if (!allowed) throw new Error("Source reference is outside this collected session.");
49
- }
50
- const gaps = [...session.trace?.source_gaps ?? [], ...session.trace && !originals?.length ? ["Only the collector-normalized export is available; original source records were not retained."] : []];
51
- mkdirSync(directory, { recursive: true, mode: 448 });
52
- const key = createHash("sha256").update(`${session.harness}\0${session.sessionId}`).digest("hex");
53
- const temporary = join(directory, `${key}.pending`);
54
- const output = createWriteStream(temporary, { mode: 384 });
55
- let streamError;
56
- output.on("error", (error) => {
57
- streamError = error;
58
- });
59
- const hash = createHash("sha256");
60
- let bytes = 0, records = 0;
61
- const write = async (value) => {
62
- const line = `${JSON.stringify(value)}
63
- `;
64
- hash.update(line);
65
- bytes += Buffer.byteLength(line);
66
- if (!output.write(line)) await once(output, "drain");
67
- if (streamError) throw streamError;
68
- };
69
- const redact = (text) => {
70
- const safe = redactLine(text, { requireStructured: true, preserveTraceSessionIds: true, expectedTraceSessionId: session.sessionId }).line;
71
- JSON.parse(safe);
72
- return safe;
73
- };
74
- let omitted = 0;
75
- const writeRecord = async (sourceFile, text) => {
76
- let safe;
77
- try {
78
- safe = redact(text);
79
- } catch (error) {
80
- if (!(error instanceof UnsafeImportError)) throw error;
81
- omitted++;
82
- await write({ source_file: sourceFile, omitted_record: { reason: "redaction_not_provable" } });
83
- return;
84
- }
85
- await write({ source_file: sourceFile, record_json: safe });
86
- records++;
87
- };
88
- try {
89
- await write({
90
- format: `agentsky.trace-source/v${SOURCE_CAPTURE_VERSION}`,
91
- record_encoding: "json-text",
92
- harness: session.harness,
93
- session_id: session.sessionId,
94
- ...context ? { workspace: context.workspace, api_base: canonicalSourceApiBase(context.apiBase), source_signature: session.signature } : {},
95
- redacted_before_upload: true,
96
- representation: session.trace && !originals?.length ? "collector-normalized" : "native",
97
- source_files: files.length,
98
- gaps
99
- });
100
- for (const [index, file] of files.entries()) {
101
- const before = statSync(file);
102
- const sourceHash = createHash("sha256");
103
- for await (const chunk of createReadStream(file)) sourceHash.update(chunk);
104
- await write({ source_file: index, name: basename(file), source_sha256: sourceHash.digest("hex"), source_bytes: before.size });
105
- const raw = createReadStream(file);
106
- const input = file.endsWith(".gz") ? raw.pipe(createGunzip()) : raw;
107
- const decoder = new TextDecoder("utf-8", { fatal: true });
108
- async function* textChunks() {
109
- for await (const chunk of input) yield decoder.decode(chunk, { stream: true });
110
- yield decoder.decode();
111
- }
112
- try {
113
- if (/\.json(?:\.gz)?$/.test(file)) {
114
- let text = "";
115
- for await (const chunk of textChunks()) text += chunk;
116
- await writeRecord(index, text);
117
- } else {
118
- let pending = "";
119
- const recordLine = async (line) => {
120
- if (!line.trim()) return;
121
- await writeRecord(index, line);
122
- };
123
- for await (const chunk of textChunks()) {
124
- pending += chunk;
125
- let newline;
126
- while ((newline = pending.indexOf("\n")) !== -1) {
127
- await recordLine(pending.slice(0, newline));
128
- pending = pending.slice(newline + 1);
129
- }
130
- }
131
- await recordLine(pending);
132
- }
133
- } finally {
134
- raw.destroy();
135
- input.destroy();
136
- }
137
- const after = statSync(file);
138
- if (before.size !== after.size || before.mtimeMs !== after.mtimeMs) throw new Error("Transcript changed while capturing; retry on the next sync.");
139
- }
140
- if (omitted) gaps.push(`${omitted} record${omitted === 1 ? "" : "s"} omitted: redaction could not be proven safe.`);
141
- await write({ capture_summary: { records, complete: gaps.length === 0, gaps } });
142
- output.end();
143
- await once(output, "finish");
144
- const descriptor = openSync(temporary, "r");
145
- try {
146
- fsyncSync(descriptor);
147
- } finally {
148
- closeSync(descriptor);
149
- }
150
- const sha256 = hash.digest("hex");
151
- const path = join(directory, `${sha256}.jsonl`);
152
- if (existsSync(path)) rmSync(temporary);
153
- else renameSync(temporary, path);
154
- const parent = openSync(directory, "r");
155
- try {
156
- fsyncSync(parent);
157
- } finally {
158
- closeSync(parent);
159
- }
160
- return { path, sha256, bytes, records, sourceFiles: files.length, complete: gaps.length === 0, gaps };
161
- } catch (error) {
162
- output.destroy();
163
- rmSync(temporary, { force: true });
164
- throw error;
165
- }
166
- }
167
-
168
- // src/trace-references.ts
169
- import { execFileSync } from "child_process";
170
- import { existsSync as existsSync2 } from "fs";
171
- import { homedir } from "os";
172
- import { dirname as dirname2 } from "path";
173
- var PULL_URL = /github\.com\/([A-Za-z0-9_.-]+)\/([A-Za-z0-9_.-]+)\/pull\/([1-9][0-9]{0,8})/g;
174
- var GMAIL_ID = /(?:message_?id|thread_?id)\\*"?\s*[:=]\s*\\*"?([0-9a-f]{16})\b/gi;
175
- var GMAIL_PATH = /(?:\/messages\/|\/threads\/|mail\.google\.com\/[^\s"\\]*[#/])([0-9a-f]{16})\b/g;
176
- var OPENS_PULL = /"(?:command|cmd|input|arguments)\\*"\s*:.*\bgh\s+pr\s+create\b/;
177
- var RESULT_WINDOW = 8;
178
- var MAX_PULLS = 80;
179
- var MAX_GMAIL = 100;
180
- var TraceReferences = class {
181
- pulls = /* @__PURE__ */ new Map();
182
- gmail = /* @__PURE__ */ new Set();
183
- opening = 0;
184
- scan(line) {
185
- const awaiting = this.opening > 0;
186
- if (awaiting) this.opening--;
187
- let credited = false;
188
- for (const match of line.matchAll(PULL_URL)) {
189
- const id = `${match[1]}/${match[2]}#${match[3]}`.toLowerCase();
190
- if (id.startsWith("owner/repo#")) continue;
191
- if (awaiting && !credited) {
192
- this.pulls.set(id, "authored");
193
- credited = true;
194
- this.opening = 0;
195
- } else if (!this.pulls.has(id)) this.pulls.set(id, "referenced");
196
- }
197
- if (OPENS_PULL.test(line)) this.opening = RESULT_WINDOW;
198
- if (/gmail|mail\.google\.com/i.test(line)) {
199
- for (const match of line.matchAll(GMAIL_ID)) this.gmail.add(match[1].toLowerCase());
200
- for (const match of line.matchAll(GMAIL_PATH)) this.gmail.add(match[1].toLowerCase());
201
- }
202
- }
203
- objects() {
204
- const pulls = [...this.pulls].sort((a, b) => Number(b[1] === "authored") - Number(a[1] === "authored")).slice(0, MAX_PULLS);
205
- return [
206
- ...pulls.map(([id, role]) => ({ type: "pr", id, role })),
207
- ...[...this.gmail].slice(0, MAX_GMAIL).map((id) => ({ type: "gmail_message", id, role: "referenced" }))
208
- ];
209
- }
210
- };
211
- var remotes = /* @__PURE__ */ new Map();
212
- function gitRemoteAt(cwd) {
213
- if (!cwd) return void 0;
214
- if (remotes.has(cwd)) return remotes.get(cwd);
215
- let remote;
216
- const home = homedir();
217
- for (let folder = cwd; folder !== home && folder !== dirname2(folder); folder = dirname2(folder)) {
218
- if (!existsSync2(folder)) continue;
219
- try {
220
- remote = execFileSync("git", ["-C", folder, "remote", "get-url", "origin"], { encoding: "utf8", timeout: 3e3, stdio: ["ignore", "pipe", "ignore"] }).trim() || void 0;
221
- } catch {
222
- remote = void 0;
223
- }
224
- break;
225
- }
226
- remotes.set(cwd, remote);
227
- return remote;
228
- }
229
-
230
- // src/trace-pending.ts
231
- import { createHash as createHash2, randomBytes } from "crypto";
232
- import { createReadStream as createReadStream2, closeSync as closeSync2, existsSync as existsSync3, fsyncSync as fsyncSync2, lstatSync, mkdirSync as mkdirSync2, openSync as openSync2, readFileSync, readdirSync, realpathSync as realpathSync2, renameSync as renameSync2, rmSync as rmSync2, statSync as statSync2, writeFileSync } from "fs";
233
- import { basename as basename2, dirname as dirname3, join as join2 } from "path";
234
- var IncompleteSourceCaptureError = class extends Error {
235
- };
236
- var digest = /^[a-f0-9]{64}$/;
237
- var record = (value) => !!value && typeof value === "object" && !Array.isArray(value);
238
- var strings = (value) => Array.isArray(value) && value.every((v) => typeof v === "string");
239
- var natural = (value) => Number.isSafeInteger(value) && Number(value) >= 0;
240
- var keyOf = (manifest) => createHash2("sha256").update(JSON.stringify([manifest.apiBase, manifest.workspace, manifest.local.harness, manifest.local.sessionId])).digest("hex");
241
- function writePrivateJson(path, value) {
242
- mkdirSync2(dirname3(path), { recursive: true, mode: 448 });
243
- if (existsSync3(path) && lstatSync(path).isSymbolicLink()) throw new Error("Refusing a symlink metadata file.");
244
- const temporary = `${path}.${randomBytes(8).toString("hex")}.pending`;
245
- try {
246
- const fd = openSync2(temporary, "wx", 384);
247
- try {
248
- writeFileSync(fd, `${JSON.stringify(value)}
249
- `);
250
- fsyncSync2(fd);
251
- } finally {
252
- closeSync2(fd);
253
- }
254
- renameSync2(temporary, path);
255
- const directory = openSync2(dirname3(path), "r");
256
- try {
257
- fsyncSync2(directory);
258
- } finally {
259
- closeSync2(directory);
260
- }
261
- } catch (error) {
262
- rmSync2(temporary, { force: true });
263
- throw error;
264
- }
265
- }
266
- function rootPath(root) {
267
- mkdirSync2(root, { recursive: true, mode: 448 });
268
- if (lstatSync(root).isSymbolicLink()) throw new Error("Source queue must not be a symlink.");
269
- return realpathSync2(root);
270
- }
271
- function validateManifest(value) {
272
- if (!record(value) || value.version !== 1 || typeof value.apiBase !== "string" || typeof value.workspace !== "string" || !value.workspace || !record(value.local) || typeof value.local.harness !== "string" || typeof value.local.sessionId !== "string" || !/^[a-z0-9_-]{1,40}$/.test(value.local.harness) || !/^[A-Za-z0-9._:@-]{1,200}$/.test(value.local.sessionId) || typeof value.local.signature !== "string" || !strings(value.local.files) || !record(value.body) || !["capturing", "ready"].includes(String(value.stage))) throw new Error("Invalid pending source descriptor.");
273
- if (value.apiBase !== canonicalSourceApiBase(value.apiBase)) throw new Error("Pending endpoint identity is not canonical.");
274
- if (value.fileId !== void 0 && (typeof value.fileId !== "string" || !/^file_[A-Za-z0-9_-]{1,200}$/.test(value.fileId))) throw new Error("Invalid pending source file id.");
275
- if (value.previewSaved !== void 0 && typeof value.previewSaved !== "boolean") throw new Error("Invalid pending preview receipt.");
276
- if (value.link !== void 0 && value.link !== null && (!record(value.link) || typeof value.link.session_id !== "string" || typeof value.link.task_id !== "string")) throw new Error("Invalid pending task link.");
277
- if (value.source !== void 0 && (!record(value.source) || typeof value.source.sha256 !== "string" || !digest.test(value.source.sha256) || !natural(value.source.bytes) || !natural(value.source.records) || !natural(value.source.sourceFiles) || typeof value.source.complete !== "boolean" || !strings(value.source.gaps))) throw new Error("Invalid pending source receipt.");
278
- if (value.stage === "ready" && !value.source) throw new Error("Pending source has no capture receipt.");
279
- }
280
- function listPendingSources(root) {
281
- if (!existsSync3(root)) return [];
282
- const canonical = rootPath(root);
283
- const keys = readdirSync(canonical).sort();
284
- for (const key of keys.filter((name) => /^\.done-[a-f0-9]{64}-[a-f0-9]{16}$/.test(name))) {
285
- const path = join2(canonical, key);
286
- if (lstatSync(path).isSymbolicLink() || dirname3(realpathSync2(path)) !== canonical) throw new Error("Unsafe completed source directory.");
287
- rmSync2(path, { recursive: true });
288
- }
289
- return keys.filter((key) => !/^\.done-[a-f0-9]{64}-[a-f0-9]{16}$/.test(key)).map((key) => {
290
- if (!digest.test(key)) throw new Error("Unexpected entry in the private source queue.");
291
- const directory = join2(canonical, key);
292
- if (!lstatSync(directory).isDirectory() || lstatSync(directory).isSymbolicLink() || dirname3(realpathSync2(directory)) !== canonical) throw new Error("Unsafe pending source directory.");
293
- const path = join2(directory, "manifest.json");
294
- if (!existsSync3(path) || !lstatSync(path).isFile() || lstatSync(path).isSymbolicLink()) throw new Error("Pending source is missing a safe descriptor.");
295
- const manifest = JSON.parse(readFileSync(path, "utf8"));
296
- validateManifest(manifest);
297
- if (key !== keyOf(manifest)) throw new Error("Pending source routing does not match its directory.");
298
- return { directory, manifest };
299
- });
300
- }
301
- function beginPendingSource(root, manifest) {
302
- const data = { ...manifest, version: 1, stage: "capturing" };
303
- validateManifest(data);
304
- const directory = join2(rootPath(root), keyOf(data));
305
- mkdirSync2(directory, { mode: 448 });
306
- const pending = { directory, manifest: data };
307
- try {
308
- savePendingSource(pending, {});
309
- } catch (error) {
310
- rmSync2(directory, { recursive: true, force: true });
311
- throw error;
312
- }
313
- return pending;
314
- }
315
- function savePendingSource(pending, patch) {
316
- const manifest = { ...pending.manifest, ...patch };
317
- validateManifest(manifest);
318
- if (basename2(pending.directory) !== keyOf(manifest)) throw new Error("Pending source identity cannot be changed.");
319
- writePrivateJson(join2(pending.directory, "manifest.json"), manifest);
320
- pending.manifest = manifest;
321
- }
322
- async function recoverPendingSource(pending) {
323
- const { manifest, directory } = pending;
324
- if (lstatSync(directory).isSymbolicLink()) throw new Error("Unsafe pending source directory.");
325
- const names = readdirSync(directory).filter((name2) => /^[a-f0-9]{64}\.jsonl$/.test(name2));
326
- const name = manifest.source ? `${manifest.source.sha256}.jsonl` : names.length === 1 ? names[0] : void 0;
327
- if (!name || names.length !== 1) throw new IncompleteSourceCaptureError("Source capture was interrupted before a complete archive was finalized; pending data retained.");
328
- const path = join2(directory, name);
329
- const before = lstatSync(path);
330
- if (!before.isFile() || before.isSymbolicLink() || dirname3(realpathSync2(path)) !== realpathSync2(directory)) throw new Error("Unsafe pending archive path.");
331
- const hash = createHash2("sha256"), decoder = new TextDecoder("utf-8", { fatal: true });
332
- let bytes = 0, records = 0, lineBuffer = "", header, summary;
333
- const files = /* @__PURE__ */ new Set();
334
- const line = (text) => {
335
- if (!text) return;
336
- const row = JSON.parse(text);
337
- if (!record(row) || summary) throw new Error("Invalid pending archive record ordering.");
338
- if (!header) {
339
- header = row;
340
- return;
341
- }
342
- if (record(row.capture_summary)) {
343
- summary = row.capture_summary;
344
- return;
345
- }
346
- if (!natural(row.source_file) || !natural(header.source_files) || row.source_file >= header.source_files) throw new Error("Invalid source file index.");
347
- if (record(row.omitted_record) && files.has(row.source_file)) return;
348
- if (typeof row.record_json === "string") {
349
- if (!files.has(row.source_file)) throw new Error("Pending record precedes its source metadata.");
350
- records++;
351
- } else if (typeof row.source_sha256 === "string" && digest.test(row.source_sha256) && natural(row.source_bytes)) files.add(row.source_file);
352
- else throw new Error("Invalid pending source record.");
353
- };
354
- for await (const chunk of createReadStream2(path)) {
355
- hash.update(chunk);
356
- bytes += chunk.length;
357
- lineBuffer += decoder.decode(chunk, { stream: true });
358
- let newline;
359
- while ((newline = lineBuffer.indexOf("\n")) !== -1) {
360
- line(lineBuffer.slice(0, newline));
361
- lineBuffer = lineBuffer.slice(newline + 1);
362
- }
363
- }
364
- lineBuffer += decoder.decode();
365
- if (lineBuffer) line(lineBuffer);
366
- const sha256 = hash.digest("hex");
367
- const after = statSync2(path);
368
- if (before.size !== after.size || before.mtimeMs !== after.mtimeMs || sha256 !== name.slice(0, -6)) throw new Error("Pending archive bytes or hash changed.");
369
- if (!header || header.format !== `agentsky.trace-source/v${SOURCE_CAPTURE_VERSION}` || header.harness !== manifest.local.harness || header.session_id !== manifest.local.sessionId || header.workspace !== manifest.workspace || header.api_base !== manifest.apiBase || header.source_signature !== manifest.local.signature || !natural(header.source_files) || files.size !== header.source_files || !summary || summary.records !== records || typeof summary.complete !== "boolean" || !strings(summary.gaps) || summary.complete !== (summary.gaps.length === 0)) throw new Error("Pending archive identity or completion receipt does not match its descriptor.");
370
- const source = { path, sha256, bytes, records, sourceFiles: header.source_files, complete: summary.complete, gaps: summary.gaps };
371
- if (manifest.source && JSON.stringify(manifest.source) !== JSON.stringify({ sha256, bytes, records, sourceFiles: source.sourceFiles, complete: source.complete, gaps: source.gaps })) throw new Error("Pending archive receipt was changed.");
372
- return source;
373
- }
374
- function completePendingCapture(pending, source) {
375
- const { path: _path, ...receipt } = source;
376
- savePendingSource(pending, { stage: "ready", source: receipt });
377
- }
378
- function removePendingSource(pending) {
379
- if (basename2(pending.directory) !== keyOf(pending.manifest) || lstatSync(pending.directory).isSymbolicLink()) throw new Error("Unsafe source cleanup path.");
380
- const completed = join2(dirname3(pending.directory), `.done-${basename2(pending.directory)}-${randomBytes(8).toString("hex")}`);
381
- renameSync2(pending.directory, completed);
382
- const fd = openSync2(dirname3(completed), "r");
383
- try {
384
- fsyncSync2(fd);
385
- } finally {
386
- closeSync2(fd);
387
- }
388
- rmSync2(completed, { recursive: true });
389
- }
390
-
391
- // src/trace-library.ts
392
- var MESSAGE_MAX_BYTES = 8 * 1024;
393
- var TOOL_MAX_BYTES = 2 * 1024;
394
- var MESSAGES_MAX = 2e4;
395
- var BODY_MAX_BYTES = 7 * 1024 * 1024;
396
- var UPLOAD_CONCURRENCY = 4;
397
- var FULL_SWEEP_MS = 7 * 24 * 60 * 60 * 1e3;
398
- var RETRIES = 3;
399
- var RATE_LIMIT_RETRIES = 30;
400
- var HARNESS_PREAMBLES = ["<environment_context>", "<user_instructions>", "<permissions instructions>", "# AGENTS.md instructions", "<INSTRUCTIONS>", "<external_codex_apps_open_page>"];
401
- var titleOf = (text) => /^\s*</.test(text) ? void 0 : text.trim().slice(0, 120) || void 0;
402
- var sleep = (ms) => new Promise((resolve2) => setTimeout(resolve2, ms));
403
- var backoffMs = (attempt) => Math.min(3e4, 1e3 * 2 ** attempt);
404
- function skyDir() {
405
- return process.env.SKY_CONFIG_DIR ?? join3(homedir2(), ".config", "sky");
406
- }
407
- function syncConfigPath() {
408
- return join3(skyDir(), "trace-sync.json");
409
- }
410
- function statePath() {
411
- return join3(skyDir(), "trace-sync-state.json");
412
- }
413
- function readJson(path, fallback) {
414
- try {
415
- return JSON.parse(readFileSync2(path, "utf8"));
416
- } catch {
417
- return fallback;
418
- }
419
- }
420
- function writeJson(path, value) {
421
- mkdirSync3(dirname4(path), { recursive: true });
422
- writeFileSync2(path, `${JSON.stringify(value, null, 2)}
423
- `, { mode: 384 });
424
- }
425
- function loadSyncConfig() {
426
- return readJson(syncConfigPath(), { enabled: false, rules: [] });
427
- }
428
- function saveSyncConfig(config) {
429
- writeJson(syncConfigPath(), config);
430
- }
431
- function claudeRoot() {
432
- return join3(process.env.CLAUDE_CONFIG_DIR ?? join3(homedir2(), ".claude"), "projects");
433
- }
434
- function codexRoot() {
435
- return process.env.CODEX_HOME ?? join3(homedir2(), ".codex");
436
- }
437
- var SKY_PARSED = /* @__PURE__ */ new Set(["claude-code", "codex"]);
438
- var COLLECTOR_HARNESS = { "claude-code": "claude_code", codex: "codex" };
439
- var collectorModules;
440
- async function traceCollector() {
441
- const dir = join3(dirname4(fileURLToPath(import.meta.url)), "..", "vendor", "trace-collect");
442
- collectorModules ??= Promise.all([
443
- import(pathToFileURL(join3(dir, "collect.mjs")).href),
444
- import(pathToFileURL(join3(dir, "sinks", "agentsky.mjs")).href)
445
- ]).then(([collector, sink]) => ({ collector, sink }));
446
- return collectorModules;
447
- }
448
- function collectorHarness(harness) {
449
- return COLLECTOR_HARNESS[harness] ?? harness.replace(/[^a-z0-9_-]/g, "_").slice(0, 40);
450
- }
451
- async function sourceFolders() {
452
- const { collector } = await traceCollector();
453
- const others = (await collector.describeSources()).filter((source) => !SKY_PARSED.has(source.id)).flatMap((source) => source.found);
454
- return [claudeRoot(), join3(codexRoot(), "sessions"), join3(codexRoot(), "archived_sessions"), ...others, collector.STORE];
455
- }
456
- async function supportedAgents() {
457
- const { collector } = await traceCollector();
458
- return (await collector.describeSources()).map(({ id, name, kind, found }) => ({ id, name, kind, found: found.length > 0 }));
459
- }
460
- async function importExport(input) {
461
- const { collector } = await traceCollector();
462
- const result = await collector.importFile(input);
463
- if (result.error) throw new Error(result.error);
464
- return { agent: result.name ?? result.id ?? "export", sessions: result.total ?? 0 };
465
- }
466
- function signatureOf(files) {
467
- const parts = [];
468
- for (const file of files) {
469
- try {
470
- const stat = statSync3(file);
471
- parts.push(`${file}:${stat.size}:${Math.floor(stat.mtimeMs)}`);
472
- } catch {
473
- return null;
474
- }
475
- }
476
- return parts.join("|");
477
- }
478
- function claudeSessions() {
479
- const root = claudeRoot();
480
- const found = [];
481
- let projects;
482
- try {
483
- projects = readdirSync2(root);
484
- } catch {
485
- return found;
486
- }
487
- for (const project of projects) {
488
- const dir = join3(root, project);
489
- let entries;
490
- try {
491
- entries = readdirSync2(dir);
492
- } catch {
493
- continue;
494
- }
495
- for (const entry of entries) {
496
- if (!entry.endsWith(".jsonl")) continue;
497
- const sessionId = entry.slice(0, -".jsonl".length);
498
- const files = [join3(dir, entry)];
499
- const subagents = join3(dir, sessionId, "subagents");
500
- try {
501
- files.push(...readdirSync2(subagents).filter((name) => name.endsWith(".jsonl")).sort().map((name) => join3(subagents, name)));
502
- } catch {
503
- }
504
- const signature = signatureOf(files);
505
- if (signature) found.push({ harness: "claude_code", sessionId, files, signature });
506
- }
507
- }
508
- return found;
509
- }
510
- async function* readLines(file) {
511
- const raw = createReadStream3(file);
512
- const input = file.endsWith(".gz") ? raw.pipe(createGunzip2()) : raw;
513
- const reader = createInterface({ input, crlfDelay: Infinity });
514
- try {
515
- for await (const line of reader) yield line;
516
- } finally {
517
- reader.close();
518
- raw.destroy();
519
- }
520
- }
521
- async function firstLine(file) {
522
- for await (const line of readLines(file)) return line.length > 1024 * 1024 ? "" : line;
523
- return "";
524
- }
525
- function codexIdCachePath() {
526
- return join3(skyDir(), "trace-sync-codex-ids.json");
527
- }
528
- async function codexSessions() {
529
- const byId = /* @__PURE__ */ new Map();
530
- const cached = readJson(codexIdCachePath(), {});
531
- const seen = {};
532
- const walk = async (dir) => {
533
- let entries;
534
- try {
535
- entries = readdirSync2(dir, { withFileTypes: true });
536
- } catch {
537
- return;
538
- }
539
- for (const entry of entries) {
540
- const full = join3(dir, entry.name);
541
- if (entry.isDirectory()) {
542
- await walk(full);
543
- continue;
544
- }
545
- if (!entry.name.startsWith("rollout-") || !/\.jsonl(\.gz)?$/.test(entry.name)) continue;
546
- const signature = signatureOf([full]);
547
- if (!signature) continue;
548
- let id = cached[full]?.signature === signature ? cached[full].id : void 0;
549
- if (!id) {
550
- try {
551
- const meta = JSON.parse(await firstLine(full));
552
- if (meta?.type === "session_meta" && typeof meta.payload?.id === "string") id = meta.payload.id;
553
- } catch {
554
- continue;
555
- }
556
- }
557
- if (!id) continue;
558
- seen[full] = { signature, id };
559
- const mtime = statSync3(full).mtimeMs;
560
- const known = byId.get(id);
561
- if (!known || mtime > known.mtime) byId.set(id, { harness: "codex", sessionId: id, files: [full], signature, mtime });
562
- }
563
- };
564
- await walk(join3(codexRoot(), "sessions"));
565
- await walk(join3(codexRoot(), "archived_sessions"));
566
- try {
567
- writeJson(codexIdCachePath(), seen);
568
- } catch {
569
- }
570
- return [...byId.values()].map(({ mtime: _mtime, ...session }) => session);
571
- }
572
- function claudeSessionAt(path) {
573
- const root = claudeRoot();
574
- if (!path.startsWith(`${root}${sep}`) || !path.endsWith(".jsonl") || basename3(dirname4(dirname4(path))) !== basename3(root)) return null;
575
- const sessionId = basename3(path, ".jsonl");
576
- const files = [path];
577
- const subagents = join3(dirname4(path), sessionId, "subagents");
578
- try {
579
- files.push(...readdirSync2(subagents).filter((name) => name.endsWith(".jsonl")).sort().map((name) => join3(subagents, name)));
580
- } catch {
581
- }
582
- const signature = signatureOf(files);
583
- return signature ? { harness: "claude_code", sessionId, files, signature } : null;
584
- }
585
- async function collectorSessions() {
586
- const { collector } = await traceCollector();
587
- const report = await collector.collect();
588
- const failed = report.filter((entry) => entry.error);
589
- if (failed.length) throw new Error(failed.map((entry) => `${entry.id}: ${entry.error}`).join("; "));
590
- const harness = (await collector.loadSources()).map((source) => source.id).filter((id) => !SKY_PARSED.has(id));
591
- const found = /* @__PURE__ */ new Map();
592
- for await (const { file, trace, id } of collector.sessions({ harness, children: true })) {
593
- const signature = signatureOf([file]);
594
- if (!signature) continue;
595
- const session = { harness: collectorHarness(trace.harness), sessionId: String(id).slice(0, 200), files: [file], signature, trace };
596
- found.set(`${session.harness}:${session.sessionId}`, session);
597
- }
598
- return [...found.values()];
599
- }
600
- async function discoverSessions(onCollectorError) {
601
- let others = [];
602
- try {
603
- others = await collectorSessions();
604
- } catch (error) {
605
- if (!onCollectorError) throw error;
606
- onCollectorError(error);
607
- }
608
- return [...claudeSessions(), ...await codexSessions(), ...others];
609
- }
610
- function asRecord(value) {
611
- return value && typeof value === "object" && !Array.isArray(value) ? value : null;
612
- }
613
- function str(value) {
614
- return typeof value === "string" && value.length ? value : void 0;
615
- }
616
- function toolResultText(content) {
617
- if (typeof content === "string") return content;
618
- if (Array.isArray(content)) return content.map((part) => str(asRecord(part)?.text) ?? "").filter(Boolean).join("\n");
619
- return "";
620
- }
621
- function stringify(value) {
622
- if (typeof value === "string") return value;
623
- try {
624
- return JSON.stringify(value);
625
- } catch {
626
- return "";
627
- }
628
- }
629
- var Collector = class {
630
- messages = [];
631
- partial = false;
632
- bytes = 0;
633
- push(role, text, at) {
634
- const trimmed = text.replace(/\u0000/g, "").trim();
635
- if (!trimmed) return;
636
- if (this.messages.length >= MESSAGES_MAX) {
637
- this.partial = true;
638
- return;
639
- }
640
- const safe = redactTraceText(trimmed, role === "tool" ? TOOL_MAX_BYTES : MESSAGE_MAX_BYTES);
641
- if (safe.truncated) this.partial = true;
642
- this.bytes += Buffer.byteLength(safe.text) + 80;
643
- this.messages.push({ role, text: safe.text, ...at ? { at } : {} });
644
- }
645
- };
646
- function isoOrUndefined(value) {
647
- const text = str(value);
648
- if (!text) return void 0;
649
- const time = Date.parse(text);
650
- return Number.isFinite(time) ? new Date(time).toISOString() : void 0;
651
- }
652
- async function collectorBody(trace, device, scrubber) {
653
- const { collector, sink } = await traceCollector();
654
- const scrubbed = (scrubber ?? collector.scrubberFor()).scrub(trace);
655
- return sink.toLibrary({ ...scrubbed, cwd: trace.cwd, stats: trace.stats }, device);
656
- }
657
- async function parseClaudeSession(session) {
658
- const out = { harness: "claude_code", sessionId: session.sessionId, userTurns: 0, toolCalls: 0, partial: false, messages: [] };
659
- const collector = new Collector();
660
- const source = new SessionSourceCollector();
661
- const references = new TraceReferences();
662
- for (const [index, file] of session.files.entries()) {
663
- for await (const line of readLines(file)) {
664
- if (!line.trim()) continue;
665
- references.scan(line);
666
- let record2;
667
- try {
668
- record2 = asRecord(JSON.parse(line));
669
- } catch {
670
- out.partial = true;
671
- continue;
672
- }
673
- if (!record2) continue;
674
- source.push(index === 0 ? record2 : { ...record2, isSidechain: true });
675
- const at = isoOrUndefined(record2.timestamp);
676
- if (index === 0) {
677
- out.cwd ??= str(record2.cwd);
678
- out.gitBranch ??= str(record2.gitBranch);
679
- if (at) {
680
- out.startedAt ??= at;
681
- out.endedAt = at;
682
- }
683
- }
684
- const message = asRecord(record2.message);
685
- if (!message || record2.isMeta === true) continue;
686
- if (record2.type === "user") {
687
- const content = message.content;
688
- if (typeof content === "string") {
689
- collector.push("user", content, at);
690
- if (index === 0) out.userTurns += 1;
691
- if (index === 0) out.title ??= titleOf(content);
692
- continue;
693
- }
694
- if (!Array.isArray(content)) continue;
695
- let typed = false;
696
- for (const part of content.map(asRecord)) {
697
- if (part?.type === "text" && str(part.text)) {
698
- collector.push("user", part.text, at);
699
- typed = true;
700
- if (index === 0) out.title ??= titleOf(part.text);
701
- } else if (part?.type === "tool_result") {
702
- collector.push("tool", toolResultText(part.content), at);
703
- }
704
- }
705
- if (typed && index === 0) out.userTurns += 1;
706
- } else if (record2.type === "assistant") {
707
- const content = Array.isArray(message.content) ? message.content.map(asRecord) : [];
708
- for (const part of content) {
709
- if (part?.type === "text") collector.push("assistant", str(part.text) ?? "", at);
710
- else if (part?.type === "tool_use") {
711
- out.toolCalls += 1;
712
- collector.push("tool", `${str(part.name) ?? "tool"} ${stringify(part.input)}`, at);
713
- }
714
- }
715
- }
716
- }
717
- }
718
- return withWorkLinks(finish(withSource(out, source.result()), collector), references);
719
- }
720
- async function parseCodexSession(session) {
721
- const out = { harness: "codex", sessionId: session.sessionId, userTurns: 0, toolCalls: 0, partial: false, messages: [] };
722
- const collector = new Collector();
723
- const source = new SessionSourceCollector();
724
- const references = new TraceReferences();
725
- for await (const line of readLines(session.files[0])) {
726
- if (!line.trim()) continue;
727
- references.scan(line);
728
- let record2;
729
- try {
730
- record2 = asRecord(JSON.parse(line));
731
- } catch {
732
- out.partial = true;
733
- continue;
734
- }
735
- source.push(record2);
736
- const payload = asRecord(record2?.payload);
737
- if (!record2 || !payload) continue;
738
- const at = isoOrUndefined(record2.timestamp);
739
- if (at) {
740
- out.startedAt ??= at;
741
- out.endedAt = at;
742
- }
743
- if (record2.type === "session_meta") {
744
- out.cwd ??= str(payload.cwd);
745
- } else if (record2.type === "turn_context") {
746
- out.cwd ??= str(payload.cwd);
747
- } else if (record2.type === "response_item") {
748
- if (payload.type === "message") {
749
- const role = payload.role === "user" ? "user" : payload.role === "assistant" ? "assistant" : null;
750
- if (!role) continue;
751
- const text = (Array.isArray(payload.content) ? payload.content : []).map((part) => str(asRecord(part)?.text) ?? "").filter(Boolean).join("\n");
752
- if (role === "user" && HARNESS_PREAMBLES.some((prefix) => text.trimStart().startsWith(prefix))) continue;
753
- collector.push(role, text, at);
754
- if (role === "user" && text.trim()) {
755
- out.userTurns += 1;
756
- out.title ??= titleOf(text);
757
- }
758
- } else if (payload.type === "function_call" || payload.type === "custom_tool_call" || payload.type === "local_shell_call") {
759
- out.toolCalls += 1;
760
- collector.push("tool", `${str(payload.name) ?? payload.type} ${stringify(payload.arguments ?? payload.input ?? payload.action)}`, at);
761
- } else if (payload.type === "function_call_output" || payload.type === "custom_tool_call_output") {
762
- const output = asRecord(payload.output);
763
- collector.push("tool", str(output?.content) ?? stringify(payload.output), at);
764
- }
765
- }
766
- }
767
- return withWorkLinks(finish(withSource(out, source.result()), collector), references);
768
- }
769
- function withWorkLinks(out, references) {
770
- const remote = out.gitRemote ?? gitRemoteAt(out.cwd);
771
- return { ...out, ...remote ? { gitRemote: publicRemote(remote) } : {}, workObjects: references.objects() };
772
- }
773
- function withSource(out, meta) {
774
- return {
775
- ...out,
776
- gitBranch: out.gitBranch ?? meta.git?.branch,
777
- gitCommit: meta.git?.commit,
778
- gitRemote: meta.git?.remote ? publicRemote(meta.git.remote) : void 0,
779
- model: meta.models?.[0],
780
- models: meta.models,
781
- harnessVersion: meta.harness_version,
782
- client: meta.client,
783
- modelProvider: meta.model_provider,
784
- effort: meta.effort,
785
- usage: meta.usage
786
- };
787
- }
788
- function finish(out, collector) {
789
- let messages = collector.messages;
790
- let partial = out.partial || collector.partial;
791
- let bytes = collector.bytes;
792
- if (bytes > BODY_MAX_BYTES) {
793
- messages = messages.map((message) => message.role === "tool" && message.text.length > 256 ? { ...message, text: `${message.text.slice(0, 256)}\u2026` } : message);
794
- bytes = messages.reduce((sum, message) => sum + Buffer.byteLength(message.text) + 80, 0);
795
- partial = true;
796
- }
797
- while (bytes > BODY_MAX_BYTES && messages.length) {
798
- const dropped = messages.splice(Math.floor(messages.length / 2), Math.max(1, Math.floor(messages.length / 10)));
799
- bytes -= dropped.reduce((sum, message) => sum + Buffer.byteLength(message.text) + 80, 0);
800
- }
801
- return { ...out, title: out.title ? redactTraceText(out.title, 300).text : void 0, partial, messages };
802
- }
803
- function isTrivial(session) {
804
- if (!session.messages.length) return true;
805
- const chars = session.messages.reduce((sum, message) => sum + message.text.length, 0);
806
- return session.toolCalls === 0 && session.messages.length <= 2 && chars < 200;
807
- }
808
- function sessionDigest(session) {
809
- const hash = createHash3("sha256");
810
- hash.update(`${session.cwd ?? ""}${session.model ?? ""}`);
811
- for (const message of session.messages) hash.update(`${message.role}\0${message.text}`);
812
- return hash.digest("hex");
813
- }
814
- function projectOf(cwd) {
815
- const parts = cwd.split(sep).filter(Boolean);
816
- for (const marker of [".worktrees", "worktrees"]) {
817
- const at = parts.lastIndexOf(marker);
818
- if (at > 0) {
819
- const owner = parts[at - 1] === ".claude" ? at - 2 : at - 1;
820
- if (owner >= 0) return parts[owner];
821
- }
822
- }
823
- let dir = cwd;
824
- while (dir && dir !== dirname4(dir)) {
825
- if (existsSync4(join3(dir, ".git"))) return basename3(dir);
826
- dir = dirname4(dir);
827
- }
828
- return parts.at(-1);
829
- }
830
- function workspaceFile(cwd) {
831
- let dir = cwd;
832
- while (dir && dir !== dirname4(dir)) {
833
- const file = join3(dir, ".agentsky.json");
834
- if (existsSync4(file)) {
835
- const workspace = str(readJson(file, {}).workspace);
836
- if (workspace) return workspace;
837
- }
838
- if (existsSync4(join3(dir, ".git"))) return void 0;
839
- dir = dirname4(dir);
840
- }
841
- return void 0;
842
- }
843
- function gitConfigPath(root) {
844
- const dotGit = join3(root, ".git");
845
- try {
846
- if (statSync3(dotGit).isDirectory()) return join3(dotGit, "config");
847
- const pointer = readFileSync2(dotGit, "utf8").match(/^gitdir:\s*(.+)$/m)?.[1]?.trim();
848
- if (!pointer) return void 0;
849
- const gitdir = pointer.startsWith("/") ? pointer : join3(root, pointer);
850
- const common = existsSync4(join3(gitdir, "commondir")) ? readFileSync2(join3(gitdir, "commondir"), "utf8").trim() : ".";
851
- return join3(common.startsWith("/") ? common : join3(gitdir, common), "config");
852
- } catch {
853
- return void 0;
854
- }
855
- }
856
- function repoRemote(cwd) {
857
- let dir = cwd;
858
- while (dir && dir !== dirname4(dir)) {
859
- if (existsSync4(join3(dir, ".git"))) {
860
- const config = gitConfigPath(dir);
861
- if (!config) return void 0;
862
- try {
863
- const text = readFileSync2(config, "utf8");
864
- return text.match(/\[remote "origin"\][^[]*?url\s*=\s*(\S+)/)?.[1];
865
- } catch {
866
- return void 0;
867
- }
868
- }
869
- dir = dirname4(dir);
870
- }
871
- return void 0;
872
- }
873
- function routeSession(cwd, config) {
874
- if (cwd) {
875
- const pinned = workspaceFile(cwd);
876
- if (pinned) return pinned;
877
- const lower = `${cwd}
878
- ${repoRemote(cwd) ?? ""}`.toLowerCase();
879
- const rule = config.rules.find((candidate) => lower.includes(candidate.match.toLowerCase()));
880
- if (rule) return rule.workspace;
881
- }
882
- return config.fallback ?? null;
883
- }
884
- function homeLabel(path) {
885
- if (!path) return void 0;
886
- const home = homedir2();
887
- return path === home || path.startsWith(`${home}${sep}`) ? `~${path.slice(home.length)}` : path;
888
- }
889
- async function libraryRequest(method, path, workspace, body, timeoutMs = 12e4) {
890
- const token = apiToken();
891
- if (!token) throw new ApiError(401, "not_logged_in", "not logged in \u2014 run `sky auth login`");
892
- const payload = body ? JSON.stringify(body) : void 0;
893
- let res;
894
- for (let attempt = 0; ; attempt++) {
895
- try {
896
- res = await fetch(`${apiBase()}${path}`, {
897
- method,
898
- headers: { "user-agent": USER_AGENT, authorization: `Bearer ${token}`, "x-universe": workspace, ...payload ? { "content-type": "application/json" } : {} },
899
- body: payload,
900
- signal: AbortSignal.timeout(timeoutMs)
901
- });
902
- } catch (error) {
903
- if (attempt >= RETRIES) throw error;
904
- await sleep(backoffMs(attempt));
905
- continue;
906
- }
907
- if (res.status === 429 && attempt < RATE_LIMIT_RETRIES) {
908
- const wait = Number(res.headers.get("retry-after"));
909
- await sleep(Number.isFinite(wait) && wait > 0 ? Math.min(wait, 65) * 1e3 : backoffMs(attempt));
910
- continue;
911
- }
912
- if (res.status >= 500 && res.status !== 503 && attempt < RETRIES) {
913
- await sleep(backoffMs(attempt));
914
- continue;
915
- }
916
- break;
917
- }
918
- if (!res.ok) {
919
- let code = "http_error";
920
- let message = `${res.status} ${res.statusText}`;
921
- try {
922
- const parsed = await res.json();
923
- code = parsed.error?.code ?? code;
924
- message = parsed.error?.message ?? message;
925
- } catch {
926
- }
927
- throw new ApiError(res.status, code, message);
928
- }
929
- return await res.json();
930
- }
931
- function uploadBody(session, sha256, device) {
932
- const cwd = homeLabel(session.cwd);
933
- return {
934
- sha256,
935
- ...session.workObjects?.length ? { work_objects: session.workObjects } : {},
936
- ...session.title ? { title: session.title } : {},
937
- ...cwd ? { cwd: cwd.slice(0, 1024) } : {},
938
- ...session.cwd && projectOf(session.cwd) ? { project: projectOf(session.cwd).slice(0, 200) } : {},
939
- ...session.gitBranch ? { git_branch: session.gitBranch.slice(0, 300) } : {},
940
- ...session.gitCommit ? { git_commit: session.gitCommit.slice(0, 80) } : {},
941
- ...session.gitRemote ? { git_remote: session.gitRemote.slice(0, 1024) } : {},
942
- ...session.model ? { model: session.model.slice(0, 200) } : {},
943
- ...session.models?.length ? { models: session.models.slice(0, 50).map((model) => model.slice(0, 200)) } : {},
944
- ...session.harnessVersion ? { harness_version: session.harnessVersion.slice(0, 80) } : {},
945
- ...session.client ? { client: session.client.slice(0, 200) } : {},
946
- ...session.modelProvider ? { model_provider: session.modelProvider.slice(0, 100) } : {},
947
- ...session.effort ? { effort: session.effort.slice(0, 100) } : {},
948
- ...session.usage && Object.keys(session.usage).length ? { usage: session.usage } : {},
949
- device: device.slice(0, 200),
950
- ...session.startedAt ? { started_at: session.startedAt } : {},
951
- ...session.endedAt ? { ended_at: session.endedAt } : {},
952
- user_turns: session.userTurns,
953
- tool_calls: session.toolCalls,
954
- partial: session.partial,
955
- messages: session.messages
956
- };
957
- }
958
- function lockPath() {
959
- return join3(skyDir(), "trace-sync.lock");
960
- }
961
- function takeLock() {
962
- const path = lockPath();
963
- mkdirSync3(skyDir(), { recursive: true });
964
- try {
965
- mkdirSync3(path);
966
- } catch {
967
- const pid = Number(readJson(join3(path, "pid.json"), {}).pid);
968
- let alive = false;
969
- try {
970
- if (pid) {
971
- process.kill(pid, 0);
972
- alive = true;
973
- }
974
- } catch {
975
- alive = false;
976
- }
977
- if (alive) return false;
978
- rmSync3(path, { recursive: true, force: true });
979
- try {
980
- mkdirSync3(path);
981
- } catch {
982
- return false;
983
- }
984
- }
985
- writeJson(join3(path, "pid.json"), { pid: process.pid });
986
- return true;
987
- }
988
- function releaseLock() {
989
- rmSync3(lockPath(), { recursive: true, force: true });
990
- }
991
- async function pool(items, size, fn) {
992
- let next = 0;
993
- await Promise.all(Array.from({ length: Math.min(size, items.length) }, async () => {
994
- while (next < items.length) await fn(items[next++]);
995
- }));
996
- }
997
- async function syncTraces(options = {}) {
998
- const config = loadSyncConfig();
999
- if (!config.enabled) throw new Error("trace sync is off on this machine \u2014 turn it on with `sky trace sync --enable`");
1000
- if (!options.dryRun && !takeLock()) return null;
1001
- try {
1002
- return await runSync(config, options);
1003
- } finally {
1004
- if (!options.dryRun) releaseLock();
1005
- }
1006
- }
1007
- async function verifyPendingFile(item, source) {
1008
- const workspace = item.manifest.workspace;
1009
- let url = `${apiBase()}/files/${encodeURIComponent(item.manifest.fileId)}/content`;
1010
- let response = await fetch(url, { redirect: "manual", headers: { authorization: `Bearer ${apiToken()}`, "x-universe": workspace, "user-agent": USER_AGENT } });
1011
- for (let redirects = 0; response.status >= 300 && response.status < 400 && redirects < 5; redirects++) {
1012
- const location = response.headers.get("location");
1013
- if (!location) throw new Error("Stored source redirect has no location.");
1014
- url = new URL(location, url).href;
1015
- if (!/^https?:/.test(url)) throw new Error("Stored source redirect has an invalid protocol.");
1016
- response = await fetch(url, { redirect: "manual", headers: { "user-agent": USER_AGENT } });
1017
- }
1018
- if (!response.ok || !response.body) throw new Error(`Cannot verify stored source file (${response.status}).`);
1019
- const hash = createHash3("sha256");
1020
- let bytes = 0;
1021
- const reader = response.body.getReader();
1022
- try {
1023
- while (true) {
1024
- const part = await reader.read();
1025
- if (part.done) break;
1026
- hash.update(part.value);
1027
- bytes += part.value.length;
1028
- }
1029
- } finally {
1030
- reader.releaseLock();
1031
- }
1032
- if (bytes !== source.bytes || hash.digest("hex") !== source.sha256) throw new Error("Stored source file does not match the pending archive; retained for retry.");
1033
- }
1034
- async function runSync(config, options) {
1035
- const state = readJson(statePath(), { sessions: {} });
1036
- const full = options.full || !state.lastFullAt || Date.now() - Date.parse(state.lastFullAt) > FULL_SWEEP_MS;
1037
- const device = config.device ?? hostname();
1038
- const report = { scanned: 0, changed: 0, uploaded: 0, unchanged: 0, local: 0, owned: 0, empty: 0, failed: 0, legacySources: 0, byWorkspace: {}, errors: [] };
1039
- const key = (s) => `${s.harness}:${s.sessionId}`;
1040
- const selected = (s) => !options.only?.length || options.only.includes(s.sessionId) || s.files.some((file) => options.only.includes(file));
1041
- const record2 = (s, value) => {
1042
- state.sessions[key(s)] = { captureVersion: SOURCE_CAPTURE_VERSION, signature: s.signature, at: (/* @__PURE__ */ new Date()).toISOString(), ...value };
1043
- };
1044
- const fail = (label, error) => {
1045
- report.failed++;
1046
- report.errors.push(`${label}: ${error.message}`);
1047
- };
1048
- try {
1049
- report.legacySources = readdirSync2(join3(skyDir(), "trace-sources")).filter((name) => /^[a-f0-9]{64}\.jsonl$/.test(name)).length;
1050
- } catch {
1051
- }
1052
- if (report.legacySources) options.onProgress?.(`${report.legacySources} unbound legacy source archives remain local; they are not uploaded or removed.`);
1053
- const queueRoot = join3(skyDir(), "trace-pending");
1054
- const endpoint = canonicalSourceApiBase(apiBase());
1055
- const restored = /* @__PURE__ */ new Map();
1056
- let blocked = false;
1057
- const unreadable = /* @__PURE__ */ new Set();
1058
- let scrubber;
1059
- const collectorFailed = (error) => fail("other agents: unreadable", error);
1060
- let discovered;
1061
- const discover = async () => discovered ??= await discoverSessions(collectorFailed);
1062
- const send = async (item) => {
1063
- const { workspace } = item.manifest;
1064
- let capturing = false;
1065
- let { local } = item.manifest;
1066
- try {
1067
- if (item.manifest.apiBase !== endpoint) throw new Error("Pending source belongs to another API endpoint; restore that endpoint before syncing new sources.");
1068
- let source;
1069
- capturing = false;
1070
- try {
1071
- source = await recoverPendingSource(item);
1072
- } catch (error) {
1073
- if (!(error instanceof IncompleteSourceCaptureError)) throw error;
1074
- capturing = true;
1075
- const native = (await discover()).find((s) => key(s) === key(local));
1076
- if (!native) throw error;
1077
- const parsed = native.trace ? null : native.harness === "claude_code" ? await parseClaudeSession(native) : await parseCodexSession(native);
1078
- const nativeCwd = native.trace?.cwd ?? parsed.cwd;
1079
- if (routeSession(nativeCwd, config) !== workspace) throw new Error("Interrupted capture no longer has its original routing authorization; pending data retained.");
1080
- if (native.signature !== local.signature) {
1081
- const body = native.trace ? await collectorBody(native.trace, device, scrubber ??= (await traceCollector()).collector.scrubberFor()) : uploadBody(parsed, sessionDigest(parsed), device);
1082
- savePendingSource(item, { local: { harness: native.harness, sessionId: native.sessionId, signature: native.signature, files: native.files }, body });
1083
- local = item.manifest.local;
1084
- }
1085
- source = await captureTraceSource(native, item.directory, { workspace, apiBase: item.manifest.apiBase });
1086
- capturing = false;
1087
- }
1088
- if (item.manifest.stage !== "ready") completePendingCapture(item, source);
1089
- const statuses = await libraryRequest("POST", "/trace-library/check", workspace, {
1090
- sessions: [{ harness: local.harness, session_id: local.sessionId, sha256: source.sha256 }]
1091
- });
1092
- if (statuses.sessions[0]?.status === "owned") {
1093
- report.owned++;
1094
- throw new Error("Another member owns this source; pending archive retained.");
1095
- }
1096
- if (item.manifest.fileId) await verifyPendingFile(item, source);
1097
- else {
1098
- const file = await uploadLargeFile(source.path, "application/x-ndjson", void 0, () => {
1099
- }, workspace);
1100
- savePendingSource(item, { fileId: file.id });
1101
- }
1102
- const { work_objects: workObjects, ...previewBody } = item.manifest.body;
1103
- const saved = await libraryRequest("PUT", `/trace-library/${local.harness}/${encodeURIComponent(local.sessionId)}`, workspace, { ...previewBody, sha256: source.sha256 });
1104
- savePendingSource(item, { previewSaved: true, link: saved.linked_task ?? null });
1105
- const link = item.manifest.link;
1106
- const linkKey = createHash3("sha256").update(JSON.stringify(link ?? null)).digest("hex").slice(0, 16);
1107
- await libraryRequest("POST", "/events", workspace, { events: [{
1108
- idempotency_key: `trace-source:${source.sha256}:${linkKey}`,
1109
- ...link ? { session_id: link.session_id, task_id: link.task_id } : {},
1110
- log: "workspace",
1111
- kind: "trace.source",
1112
- source: { system: "local-trace-collector", kind: local.harness, version: String(SOURCE_CAPTURE_VERSION) },
1113
- surface: "cli",
1114
- actor: { kind: "person" },
1115
- objects: [{ type: "local_session", id: key(local), role: "source" }, ...workObjects ?? []],
1116
- payload: {
1117
- harness: local.harness,
1118
- session_id: local.sessionId,
1119
- sha256: source.sha256,
1120
- redacted_before_upload: true,
1121
- records: source.records,
1122
- source_files: source.sourceFiles,
1123
- source_file_id: item.manifest.fileId,
1124
- gaps: source.gaps,
1125
- library_is_preview: true
1126
- },
1127
- bodies: [{ role: "transcript", media_type: "application/x-ndjson", file_id: item.manifest.fileId, complete: source.complete }]
1128
- }] });
1129
- record2(local, { workspace, sha256: source.sha256, status: source.complete ? "stored" : "stored_with_gaps" });
1130
- writePrivateJson(statePath(), state);
1131
- removePendingSource(item);
1132
- restored.set(key(local), local.signature);
1133
- report.uploaded++;
1134
- report.byWorkspace[workspace] = (report.byWorkspace[workspace] ?? 0) + 1;
1135
- } catch (error) {
1136
- if (capturing) unreadable.add(key(local));
1137
- else blocked = true;
1138
- fail(`${key(local)} \u2192 ${workspace}`, error);
1139
- }
1140
- };
1141
- if (!options.dryRun) {
1142
- let existing;
1143
- try {
1144
- existing = listPendingSources(queueRoot);
1145
- } catch (error) {
1146
- fail("pending source queue", error);
1147
- return report;
1148
- }
1149
- report.scanned = existing.length;
1150
- report.changed = existing.length;
1151
- for (let start = 0; start < existing.length; start += UPLOAD_CONCURRENCY) {
1152
- await pool(existing.slice(start, start + UPLOAD_CONCURRENCY), UPLOAD_CONCURRENCY, send);
1153
- if (blocked) return report;
1154
- }
1155
- }
1156
- const direct = options.only?.length ? options.only.map(claudeSessionAt) : [];
1157
- const sessions = (direct.length && direct.every(Boolean) ? direct : await discover()).filter(selected);
1158
- report.scanned = Math.max(report.scanned, sessions.length);
1159
- let pending = sessions.filter((s) => !unreadable.has(key(s)) && restored.get(key(s)) !== s.signature && (full || state.sessions[key(s)]?.captureVersion !== SOURCE_CAPTURE_VERSION || state.sessions[key(s)]?.signature !== s.signature));
1160
- if (options.limit) pending = pending.slice(0, options.limit);
1161
- report.changed += pending.length;
1162
- const prepare = async (local) => {
1163
- if (local.trace) {
1164
- const workspace2 = routeSession(local.trace.cwd, config);
1165
- if (!workspace2) {
1166
- report.local++;
1167
- record2(local, { workspace: null, status: "local" });
1168
- return null;
1169
- }
1170
- scrubber ??= (await traceCollector()).collector.scrubberFor();
1171
- return { workspace: workspace2, body: await collectorBody(local.trace, device, scrubber) };
1172
- }
1173
- const parsed = local.harness === "claude_code" ? await parseClaudeSession(local) : await parseCodexSession(local);
1174
- const workspace = routeSession(parsed.cwd, config);
1175
- if (!workspace) {
1176
- report.local++;
1177
- record2(local, { workspace: null, status: "local" });
1178
- return null;
1179
- }
1180
- return { workspace, body: uploadBody(parsed, sessionDigest(parsed), device) };
1181
- };
1182
- for (let start = 0; start < pending.length; start += UPLOAD_CONCURRENCY) {
1183
- const ready = [];
1184
- await pool(pending.slice(start, start + UPLOAD_CONCURRENCY), UPLOAD_CONCURRENCY, async (local) => {
1185
- try {
1186
- const prepared = await prepare(local);
1187
- if (!prepared) return;
1188
- if (options.dryRun) {
1189
- const directory = mkdtempSync(join3(skyDir(), "trace-dry-run-"));
1190
- try {
1191
- const source2 = await captureTraceSource(local, directory, { workspace: prepared.workspace, apiBase: endpoint });
1192
- const checked = await libraryRequest("POST", "/trace-library/check", prepared.workspace, { sessions: [{ harness: local.harness, session_id: local.sessionId, sha256: source2.sha256 }] });
1193
- if (checked.sessions[0]?.status === "owned") {
1194
- report.owned++;
1195
- return;
1196
- }
1197
- report.uploaded++;
1198
- report.byWorkspace[prepared.workspace] = (report.byWorkspace[prepared.workspace] ?? 0) + 1;
1199
- } finally {
1200
- rmSync3(directory, { recursive: true, force: true });
1201
- }
1202
- return;
1203
- }
1204
- const item = beginPendingSource(queueRoot, {
1205
- apiBase: endpoint,
1206
- workspace: prepared.workspace,
1207
- local: { harness: local.harness, sessionId: local.sessionId, signature: local.signature, files: local.files },
1208
- body: prepared.body
1209
- });
1210
- const source = await captureTraceSource(local, item.directory, { workspace: prepared.workspace, apiBase: item.manifest.apiBase });
1211
- completePendingCapture(item, source);
1212
- ready.push(item);
1213
- } catch (error) {
1214
- fail(`${key(local)}: source capture failed`, error);
1215
- }
1216
- });
1217
- await pool(ready, UPLOAD_CONCURRENCY, send);
1218
- if (blocked) break;
1219
- options.onProgress?.(`${Math.min(start + UPLOAD_CONCURRENCY, pending.length)}/${pending.length} checked, ${report.uploaded} uploaded so far`);
1220
- }
1221
- if (!options.dryRun) {
1222
- if (full && !options.only?.length && !options.limit && report.failed === 0) state.lastFullAt = (/* @__PURE__ */ new Date()).toISOString();
1223
- writePrivateJson(statePath(), state);
1224
- }
1225
- return report;
1226
- }
1227
- function hookSessionRef(payload) {
1228
- try {
1229
- const value = asRecord(JSON.parse(payload));
1230
- return str(value?.transcript_path) ?? str(value?.session_id) ?? str(value?.["thread-id"]) ?? str(value?.thread_id);
1231
- } catch {
1232
- return void 0;
1233
- }
1234
- }
1235
- var LAUNCHD_LABEL = "dev.agentsky.trace-sync";
1236
- function installLaunchd(command, logPath) {
1237
- if (process.platform !== "darwin") throw new Error("the schedule installer covers macOS; on Linux add `*/15 * * * * sky trace sync --quiet` to your crontab");
1238
- const plist = join3(homedir2(), "Library", "LaunchAgents", `${LAUNCHD_LABEL}.plist`);
1239
- const escape = (value) => value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
1240
- writeFileSync2(plist, `<?xml version="1.0" encoding="UTF-8"?>
1241
- <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
1242
- <plist version="1.0">
1243
- <dict>
1244
- <key>Label</key><string>${LAUNCHD_LABEL}</string>
1245
- <key>ProgramArguments</key>
1246
- <array>
1247
- ${command.map((part) => ` <string>${escape(part)}</string>`).join("\n")}
1248
- </array>
1249
- <key>StartInterval</key><integer>900</integer>
1250
- <key>RunAtLoad</key><true/>
1251
- <key>ProcessType</key><string>Background</string>
1252
- <key>StandardOutPath</key><string>${escape(logPath)}</string>
1253
- <key>StandardErrorPath</key><string>${escape(logPath)}</string>
1254
- </dict>
1255
- </plist>
1256
- `);
1257
- return plist;
1258
- }
1259
- export {
1260
- LAUNCHD_LABEL,
1261
- collectorBody,
1262
- collectorHarness,
1263
- discoverSessions,
1264
- hookSessionRef,
1265
- importExport,
1266
- installLaunchd,
1267
- isTrivial,
1268
- libraryRequest,
1269
- loadSyncConfig,
1270
- parseClaudeSession,
1271
- parseCodexSession,
1272
- projectOf,
1273
- repoRemote,
1274
- routeSession,
1275
- saveSyncConfig,
1276
- sessionDigest,
1277
- sourceFolders,
1278
- supportedAgents,
1279
- syncConfigPath,
1280
- syncTraces
1281
- };