@oxagen/cli 3.0.1-816 → 3.0.1-818
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/oxagen.mjs +1891 -271
- package/package.json +1 -1
package/oxagen.mjs
CHANGED
|
@@ -5722,7 +5722,7 @@ function bundleSkillChars(skill) {
|
|
|
5722
5722
|
chars += file.path.length + file.content.length;
|
|
5723
5723
|
return chars;
|
|
5724
5724
|
}
|
|
5725
|
-
var protocolTimestampSchema, machineGroupSchema, TACHO_BATCH_SCHEMA, TACHO_BUNDLE_SCHEMA, TACHO_COMMANDS_SCHEMA, TACHO_ENROLLMENT_CLAIMS_SCHEMA, TACHO_ENROLLMENT_CERTIFICATE_DOMAIN, ENROLLMENT_KEY_SET_SCHEMA, ENROLLMENT_KEY_SET_DOMAIN, TACHO_ENFORCEMENT_TIER_ATTR, TACHO_GATEWAY_TIER, TACHO_GATEWAY_SESSION_HEADER, TACHO_GATEWAY_GENESIS_HEADER, REFUSAL_META_KEY, DECISION_META_KEY, MCP_STREAMABLE_HTTP_ACCEPT, TACHO_METERING_ATTR, TACHO_METERING_OBSERVED, TACHO_MODEL_SESSION_HEADER, TACHO_CREDENTIAL_BASIS_ATTR, TACHO_CREDENTIAL_GATEWAY_BROKERED, TACHO_CREDENTIAL_HARNESS_HELD, TACHO_CREDENTIAL_BASES, TACHO_RUN_TOKEN_ATTR, BUNDLE_FEATURE_GATEWAY_TOOLS, BUNDLE_FEATURE_MODEL_PRICES, BUNDLE_FEATURE_MODEL_PRICES_LONG_CONTEXT, BUNDLE_FEATURE_MODEL_ALLOWLIST, BUNDLE_FEATURE_INDEPENDENT_MODELS, BUNDLE_FEATURE_HOOK_FAIL_OPEN, BUNDLE_FEATURE_STEERING_MANIFEST, BUNDLE_FEATURE_STEERING_INCOMPLETE, BUNDLE_FEATURE_STEERING_LOAD, BUNDLE_FEATURE_CONTAINMENT, BUNDLE_FEATURE_DAILY_BUDGET, BUNDLE_FEATURE_STEER_NEXT_STEP, BUNDLE_FEATURE_UNBOUND_REPO, BUNDLE_FEATURE_CEDAR, BUNDLE_FEATURE_CEDAR_TOOLBELT, BUNDLE_FEATURE_SKILLS, BUNDLE_FEATURE_CACHE_KEEP_ALIVE, BUNDLE_FEATURE_WORK_ORDERS, BUNDLE_FEATURE_WORK_ORDER_START, BUNDLE_FEATURE_WORK_ORDER_STAFFING, BUNDLE_FEATURE_MCP_RULE_SETS, BUNDLE_FEATURE_GATEWAY_POLICY, BUNDLE_FEATURE_TENANT_SCOPE, BUNDLE_FEATURE_MEMORY_SCOPE, MEMORY_SCOPE_DIGESTS_MAX, GATEWAY_MIN_TIERS, SENSITIVE_SCREEN_ACTIONS, PROMPT_REDACTION_PATTERNS_MAX, PROMPT_REDACTION_PATTERN_MAX, gatewayPolicySchema, TACHO_BUNDLE_FEATURES, bundleFeaturesSchema, hostEnrollmentIdSchema, MEMBER_PUBLIC_ID, tachoPlatformSchema, tachoHarnessSchema, TACHO_HARNESS_LABELS, TACHO_HARNESS_TIERS, WRAPPED_HARNESSES, CONNECTED_HARNESSES, HARNESS_BINARY, MODEL_HARNESS_ROUTES, MODEL_ROUTED_HARNESSES, BROKERABLE_HARNESSES, BROKERABLE_HARNESS_PROVIDER, TACHO_TIER_SUMMARY, CUSTOM_AGENT_NAME_PATTERN, RESERVED_AGENT_NAMES, tachoHostStatusSchema, tachoBundleModeSchema, tachoCommandSchema, tachoCommandStatusSchema, tachoCommandAckStatusSchema, tachoDeliveryModeSchema, denyGenerationSchema, deliveredCommandSchema, deliveredCommandResponseSchema, WORK_ORDER_ID_PATTERN, WORK_ORDER_TOKEN_PATTERN, WORK_ITEM_ID_PATTERN, workOrderCommandPayloadSchema, HOST_WORK_ORDERS_PATH, WORK_ORDER_CLAIM_PATH, CERTIFICATE_RENEW_PATH, ENROLLMENT_KEYS_PATH, WORK_ORDER_REJECT_PATH, workOrderClaimResponseSchema, workOrderRejectResponseSchema, WORK_CRITERION_CLAIM_PATH, WORK_CRITERION_ID_PATTERN, WORK_HEAD_SHA_PATTERN, WORK_CRITERION_CLAIM_TEXT_MAX, workCriterionClaimResponseSchema, WORK_ORDER_PROGRESS_PATH, WORK_PROGRESS_TEXT_MAX, WORK_PROGRESS_STEP_MAX, workProgressResponseSchema, WORK_ORDER_ENV, WORK_ORDER_TOKEN_ENV, WORK_ORDER_TOKEN_HEADER, WORK_ORDER_ATTR, steeringForceSchema, steeringItemKindSchema, steeringCutReasonSchema, steeringHeldLoadSchema, steeringManifestItemSchema, STEERING_MANIFEST_SCHEMA, steeringManifestSchema, steeringManifestFrameSchema, workOrderSteeringReasonSchema, workOrderSteeringItemSchema, workOrderSteeringManifestSchema, cedarIdSchema, cedarPrincipalSchema, cedarToolSchema, cedarBundleSchema, BUNDLE_SKILLS_MAX, BUNDLE_SKILL_FILES_MAX, BUNDLE_SKILLS_CHARS_MAX, BASE64_PATTERN, bundleSkillFileSchema, bundleSkillSchema, policyBundleSchema, enrollmentClaimsSchema, ed25519SignatureSchema, enrollmentCertificateSchema, enrollmentKeySchema, enrollmentKeySetSchema, tachoEventWireSchema, TACHO_MAX_HELD_SESSIONS, daemonHealthSchema, TACHO_MAX_BATCH, TACHO_MAX_BODY_BYTES, TACHO_MAX_REQUEST_BYTES, TACHO_REQUEST_ENVELOPE_BYTES, SANDBOX_GIT_RELAY_PATH, SANDBOX_GITLAB_RELAY_PATH, SANDBOX_GIT_RELAY_MAX_REQUEST_BYTES, SANDBOX_GIT_RELAY_TIMEOUT_MS, tachoBodySchema, tachoBatchSchema, agentDaySpendSchema, controlEnvelopeSchema, ingestResponseSchema, bundleResponseSchema, commandAcknowledgementSchema, commandsResponseSchema, certificateRenewalResponseSchema, enrollmentKeysResponseSchema, enrollmentResponseSchema, tokenEnrollmentResponseSchema;
|
|
5725
|
+
var protocolTimestampSchema, machineGroupSchema, TACHO_BATCH_SCHEMA, TACHO_BUNDLE_SCHEMA, TACHO_COMMANDS_SCHEMA, TACHO_ENROLLMENT_CLAIMS_SCHEMA, TACHO_ENROLLMENT_CERTIFICATE_DOMAIN, ENROLLMENT_KEY_SET_SCHEMA, ENROLLMENT_KEY_SET_DOMAIN, TACHO_ENFORCEMENT_TIER_ATTR, TACHO_GATEWAY_TIER, TACHO_GATEWAY_SESSION_HEADER, TACHO_GATEWAY_GENESIS_HEADER, REFUSAL_META_KEY, DECISION_META_KEY, MCP_STREAMABLE_HTTP_ACCEPT, TACHO_METERING_ATTR, TACHO_METERING_OBSERVED, TACHO_MODEL_SESSION_HEADER, TACHO_CREDENTIAL_BASIS_ATTR, TACHO_CREDENTIAL_GATEWAY_BROKERED, TACHO_CREDENTIAL_HARNESS_HELD, TACHO_CREDENTIAL_BASES, TACHO_RUN_TOKEN_ATTR, BUNDLE_FEATURE_GATEWAY_TOOLS, BUNDLE_FEATURE_MODEL_PRICES, BUNDLE_FEATURE_MODEL_PRICES_LONG_CONTEXT, BUNDLE_FEATURE_MODEL_ALLOWLIST, BUNDLE_FEATURE_INDEPENDENT_MODELS, BUNDLE_FEATURE_HOOK_FAIL_OPEN, BUNDLE_FEATURE_STEERING_MANIFEST, BUNDLE_FEATURE_STEERING_INCOMPLETE, BUNDLE_FEATURE_STEERING_LOAD, BUNDLE_FEATURE_CONTAINMENT, BUNDLE_FEATURE_DAILY_BUDGET, BUNDLE_FEATURE_STEER_NEXT_STEP, BUNDLE_FEATURE_UNBOUND_REPO, BUNDLE_FEATURE_CEDAR, BUNDLE_FEATURE_CEDAR_TOOLBELT, BUNDLE_FEATURE_SKILLS, BUNDLE_FEATURE_CACHE_KEEP_ALIVE, BUNDLE_FEATURE_WORK_ORDERS, BUNDLE_FEATURE_WORK_ORDER_START, BUNDLE_FEATURE_WORK_ORDER_STAFFING, BUNDLE_FEATURE_MCP_RULE_SETS, BUNDLE_FEATURE_GATEWAY_POLICY, BUNDLE_FEATURE_TENANT_SCOPE, BUNDLE_FEATURE_MEMORY_SCOPE, MEMORY_SCOPE_DIGESTS_MAX, GATEWAY_MIN_TIERS, SENSITIVE_SCREEN_ACTIONS, PROMPT_REDACTION_PATTERNS_MAX, PROMPT_REDACTION_PATTERN_MAX, gatewayPolicySchema, TACHO_BUNDLE_FEATURES, bundleFeaturesSchema, hostEnrollmentIdSchema, MEMBER_PUBLIC_ID, tachoPlatformSchema, tachoHarnessSchema, TACHO_HARNESS_LABELS, TACHO_HARNESS_TIERS, WRAPPED_HARNESSES, CONNECTED_HARNESSES, HARNESS_BINARY, MODEL_HARNESS_ROUTES, MODEL_ROUTED_HARNESSES, BROKERABLE_HARNESSES, BROKERABLE_HARNESS_PROVIDER, TACHO_TIER_SUMMARY, CUSTOM_AGENT_NAME_PATTERN, RESERVED_AGENT_NAMES, tachoHostStatusSchema, tachoBundleModeSchema, tachoCommandSchema, tachoCommandStatusSchema, tachoCommandAckStatusSchema, tachoDeliveryModeSchema, denyGenerationSchema, deliveredCommandSchema, deliveredCommandResponseSchema, WORK_ORDER_ID_PATTERN, WORK_ORDER_TOKEN_PATTERN, WORK_ITEM_ID_PATTERN, workOrderCommandPayloadSchema, HOST_WORK_ORDERS_PATH, WORK_ORDER_CLAIM_PATH, CERTIFICATE_RENEW_PATH, ENROLLMENT_KEYS_PATH, WORK_ORDER_REJECT_PATH, HOST_MODEL_CREDENTIALS_PATH, HOST_MODEL_CREDENTIAL_STATE_PATH, VAULT_CREDENTIAL_ID_PATTERN, hostModelCredentialSchema, hostModelCredentialsResponseSchema, hostModelCredentialStateResponseSchema, workOrderClaimResponseSchema, workOrderRejectResponseSchema, WORK_CRITERION_CLAIM_PATH, WORK_CRITERION_ID_PATTERN, WORK_HEAD_SHA_PATTERN, WORK_CRITERION_CLAIM_TEXT_MAX, workCriterionClaimResponseSchema, WORK_ORDER_PROGRESS_PATH, WORK_PROGRESS_TEXT_MAX, WORK_PROGRESS_STEP_MAX, workProgressResponseSchema, WORK_ORDER_ENV, WORK_ORDER_TOKEN_ENV, WORK_ORDER_TOKEN_HEADER, WORK_ORDER_ATTR, steeringForceSchema, steeringItemKindSchema, steeringCutReasonSchema, steeringHeldLoadSchema, steeringManifestItemSchema, STEERING_MANIFEST_SCHEMA, steeringManifestSchema, steeringManifestFrameSchema, workOrderSteeringReasonSchema, workOrderSteeringItemSchema, workOrderSteeringManifestSchema, cedarIdSchema, cedarPrincipalSchema, cedarToolSchema, cedarBundleSchema, BUNDLE_SKILLS_MAX, BUNDLE_SKILL_FILES_MAX, BUNDLE_SKILLS_CHARS_MAX, BASE64_PATTERN, bundleSkillFileSchema, bundleSkillSchema, policyBundleSchema, enrollmentClaimsSchema, ed25519SignatureSchema, enrollmentCertificateSchema, enrollmentKeySchema, enrollmentKeySetSchema, tachoEventWireSchema, TACHO_MAX_HELD_SESSIONS, daemonHealthSchema, TACHO_MAX_BATCH, TACHO_MAX_BODY_BYTES, TACHO_MAX_REQUEST_BYTES, TACHO_REQUEST_ENVELOPE_BYTES, SANDBOX_GIT_RELAY_PATH, SANDBOX_GITLAB_RELAY_PATH, SANDBOX_GIT_RELAY_MAX_REQUEST_BYTES, SANDBOX_GIT_RELAY_TIMEOUT_MS, tachoBodySchema, tachoBatchSchema, agentDaySpendSchema, controlEnvelopeSchema, ingestResponseSchema, bundleResponseSchema, commandAcknowledgementSchema, commandsResponseSchema, certificateRenewalResponseSchema, enrollmentKeysResponseSchema, enrollmentResponseSchema, tokenEnrollmentResponseSchema;
|
|
5726
5726
|
var init_wire = __esm({
|
|
5727
5727
|
"../../packages/tacho/src/wire.ts"() {
|
|
5728
5728
|
"use strict";
|
|
@@ -5994,6 +5994,27 @@ var init_wire = __esm({
|
|
|
5994
5994
|
CERTIFICATE_RENEW_PATH = "/v1/tacho/certificate";
|
|
5995
5995
|
ENROLLMENT_KEYS_PATH = "/v1/enrollment/keys";
|
|
5996
5996
|
WORK_ORDER_REJECT_PATH = `${HOST_WORK_ORDERS_PATH}/reject`;
|
|
5997
|
+
HOST_MODEL_CREDENTIALS_PATH = "/v1/tacho/model-credentials";
|
|
5998
|
+
HOST_MODEL_CREDENTIAL_STATE_PATH = `${HOST_MODEL_CREDENTIALS_PATH}/state`;
|
|
5999
|
+
VAULT_CREDENTIAL_ID_PATTERN = /^vlt_[0-9a-z]+$/;
|
|
6000
|
+
hostModelCredentialSchema = external_exports.object({
|
|
6001
|
+
id: external_exports.string().regex(VAULT_CREDENTIAL_ID_PATTERN),
|
|
6002
|
+
provider: external_exports.string(),
|
|
6003
|
+
authType: external_exports.string(),
|
|
6004
|
+
harness: external_exports.string().nullable(),
|
|
6005
|
+
hint: external_exports.string(),
|
|
6006
|
+
label: external_exports.string().nullable(),
|
|
6007
|
+
status: external_exports.string(),
|
|
6008
|
+
limitedUntil: external_exports.string().nullable(),
|
|
6009
|
+
rotatedAt: external_exports.string().nullable(),
|
|
6010
|
+
createdAt: external_exports.string(),
|
|
6011
|
+
secret: external_exports.string().min(1)
|
|
6012
|
+
}).passthrough();
|
|
6013
|
+
hostModelCredentialsResponseSchema = external_exports.object({
|
|
6014
|
+
harness: external_exports.string(),
|
|
6015
|
+
credentials: external_exports.array(hostModelCredentialSchema)
|
|
6016
|
+
}).passthrough();
|
|
6017
|
+
hostModelCredentialStateResponseSchema = external_exports.object({ credential_id: external_exports.string(), recorded: external_exports.boolean() }).passthrough();
|
|
5997
6018
|
workOrderClaimResponseSchema = external_exports.object({
|
|
5998
6019
|
repeat: external_exports.boolean(),
|
|
5999
6020
|
work_order: external_exports.object({
|
|
@@ -16769,8 +16790,8 @@ var init_backfill = __esm({
|
|
|
16769
16790
|
this.parentMs = ms;
|
|
16770
16791
|
this.clock.ms = ms;
|
|
16771
16792
|
}
|
|
16772
|
-
const
|
|
16773
|
-
return { events: this.mappedLine(parsed2, text6, offset,
|
|
16793
|
+
const spawn10 = [];
|
|
16794
|
+
return { events: this.mappedLine(parsed2, text6, offset, spawn10), spawn: spawn10 };
|
|
16774
16795
|
}
|
|
16775
16796
|
/**
|
|
16776
16797
|
* Begin a session still waiting for its facts once its last line is read:
|
|
@@ -16796,28 +16817,28 @@ var init_backfill = __esm({
|
|
|
16796
16817
|
this.parentMs = timestampOf(first) ?? 0;
|
|
16797
16818
|
this.clock.ms = this.parentMs;
|
|
16798
16819
|
const events = this.collect(this.start(first, facts, permissionMode));
|
|
16799
|
-
const
|
|
16820
|
+
const spawn10 = [];
|
|
16800
16821
|
for (const item of early) {
|
|
16801
16822
|
const ms = timestampOf(item.record);
|
|
16802
16823
|
if (ms !== void 0) this.parentMs = Math.max(this.parentMs, ms);
|
|
16803
16824
|
this.clock.ms = ms ?? this.parentMs;
|
|
16804
16825
|
events.push(
|
|
16805
|
-
...this.mappedLine(item.record, item.text, item.offset,
|
|
16826
|
+
...this.mappedLine(item.record, item.text, item.offset, spawn10)
|
|
16806
16827
|
);
|
|
16807
16828
|
}
|
|
16808
16829
|
this.clock.ms = this.parentMs;
|
|
16809
|
-
return { events, spawn:
|
|
16830
|
+
return { events, spawn: spawn10 };
|
|
16810
16831
|
}
|
|
16811
16832
|
/** One parent line through the mapping, guarded. */
|
|
16812
|
-
mappedLine(record2, text6, offset,
|
|
16833
|
+
mappedLine(record2, text6, offset, spawn10) {
|
|
16813
16834
|
const spawnedBefore = this.spawned.size;
|
|
16814
|
-
const spawnLength =
|
|
16835
|
+
const spawnLength = spawn10.length;
|
|
16815
16836
|
return this.guarded(
|
|
16816
16837
|
offset,
|
|
16817
16838
|
void 0,
|
|
16818
|
-
() => this.mapped(record2, text6,
|
|
16839
|
+
() => this.mapped(record2, text6, spawn10),
|
|
16819
16840
|
() => {
|
|
16820
|
-
|
|
16841
|
+
spawn10.length = spawnLength;
|
|
16821
16842
|
for (const toolUseId of [...this.spawned.keys()].slice(spawnedBefore))
|
|
16822
16843
|
this.spawned.delete(toolUseId);
|
|
16823
16844
|
}
|
|
@@ -17034,7 +17055,7 @@ var init_backfill = __esm({
|
|
|
17034
17055
|
})
|
|
17035
17056
|
);
|
|
17036
17057
|
}
|
|
17037
|
-
mapped(record2, text6,
|
|
17058
|
+
mapped(record2, text6, spawn10) {
|
|
17038
17059
|
const type = nonEmptyString(record2["type"]);
|
|
17039
17060
|
const ms = timestampOf(record2);
|
|
17040
17061
|
const events = [];
|
|
@@ -17167,7 +17188,7 @@ var init_backfill = __esm({
|
|
|
17167
17188
|
ms
|
|
17168
17189
|
)
|
|
17169
17190
|
);
|
|
17170
|
-
|
|
17191
|
+
spawn10.push(subagent.agentId);
|
|
17171
17192
|
}
|
|
17172
17193
|
return events;
|
|
17173
17194
|
}
|
|
@@ -18362,11 +18383,11 @@ function requestOf(content) {
|
|
|
18362
18383
|
if (content === void 0) return void 0;
|
|
18363
18384
|
if (!content.content_type.startsWith("application/json")) return void 0;
|
|
18364
18385
|
try {
|
|
18365
|
-
const
|
|
18386
|
+
const exchange2 = JSON.parse(
|
|
18366
18387
|
Buffer.from(content.bytes).toString("utf8")
|
|
18367
18388
|
);
|
|
18368
|
-
if (!isObject(
|
|
18369
|
-
const text6 =
|
|
18389
|
+
if (!isObject(exchange2)) return "unreadable";
|
|
18390
|
+
const text6 = exchange2["request"];
|
|
18370
18391
|
if (typeof text6 !== "string") return "unreadable";
|
|
18371
18392
|
const request3 = JSON.parse(text6);
|
|
18372
18393
|
return isObject(request3) ? { text: text6, request: request3 } : "unreadable";
|
|
@@ -21051,14 +21072,14 @@ var init_recorder = __esm({
|
|
|
21051
21072
|
const parent = this.options.parent;
|
|
21052
21073
|
if (parent === void 0) return;
|
|
21053
21074
|
const type = parent.subagentType === void 0 ? subagentType : void 0;
|
|
21054
|
-
const
|
|
21055
|
-
if (type === void 0 &&
|
|
21075
|
+
const spawn10 = parent.spawnToolUseId === void 0 ? spawnToolUseId : void 0;
|
|
21076
|
+
if (type === void 0 && spawn10 === void 0) return;
|
|
21056
21077
|
this.options = {
|
|
21057
21078
|
...this.options,
|
|
21058
21079
|
parent: {
|
|
21059
21080
|
...parent,
|
|
21060
21081
|
...type !== void 0 ? { subagentType: type } : {},
|
|
21061
|
-
...
|
|
21082
|
+
...spawn10 !== void 0 ? { spawnToolUseId: spawn10 } : {}
|
|
21062
21083
|
}
|
|
21063
21084
|
};
|
|
21064
21085
|
}
|
|
@@ -24774,12 +24795,12 @@ async function sealTranscript(candidate, deps, pass2) {
|
|
|
24774
24795
|
const read2 = await readSlices(candidate.path, sliceBytes, async (lines) => {
|
|
24775
24796
|
let index = 0;
|
|
24776
24797
|
while (index < lines.length) {
|
|
24777
|
-
const
|
|
24798
|
+
const spawn10 = [];
|
|
24778
24799
|
await deps.exclusive(candidate.sessionId, () => {
|
|
24779
24800
|
if (deps.heldLocally(candidate.sessionId)) throw new TakenLive();
|
|
24780
24801
|
const out = [];
|
|
24781
24802
|
let next = readTo;
|
|
24782
|
-
while (
|
|
24803
|
+
while (spawn10.length === 0) {
|
|
24783
24804
|
const line = lines[index];
|
|
24784
24805
|
if (line === void 0) break;
|
|
24785
24806
|
index += 1;
|
|
@@ -24790,7 +24811,7 @@ async function sealTranscript(candidate, deps, pass2) {
|
|
|
24790
24811
|
}
|
|
24791
24812
|
const sealed = driver.line(line.text, line.offset);
|
|
24792
24813
|
out.push(...sealed.events);
|
|
24793
|
-
|
|
24814
|
+
spawn10.push(...sealed.spawn);
|
|
24794
24815
|
}
|
|
24795
24816
|
emit(out);
|
|
24796
24817
|
if (driver.hasChain) {
|
|
@@ -24798,7 +24819,7 @@ async function sealTranscript(candidate, deps, pass2) {
|
|
|
24798
24819
|
partial2(readTo, { status: "partial" });
|
|
24799
24820
|
}
|
|
24800
24821
|
});
|
|
24801
|
-
for (const agentId of
|
|
24822
|
+
for (const agentId of spawn10) await feedSubagent(agentId);
|
|
24802
24823
|
}
|
|
24803
24824
|
await between();
|
|
24804
24825
|
});
|
|
@@ -26189,6 +26210,207 @@ var init_claude_code_mcp = __esm({
|
|
|
26189
26210
|
}
|
|
26190
26211
|
});
|
|
26191
26212
|
|
|
26213
|
+
// ../../packages/tacho/src/collector/model-failure.ts
|
|
26214
|
+
function isUsageLimit(failure4) {
|
|
26215
|
+
return failure4.kind === "rate_limit" || failure4.kind === "usage_limit" || failure4.kind === "credit_exhausted";
|
|
26216
|
+
}
|
|
26217
|
+
function mayBeModelFailure(provider, status2) {
|
|
26218
|
+
return status2 === 401 || status2 === 403 || status2 === 429 || provider === "anthropic" && status2 === 400;
|
|
26219
|
+
}
|
|
26220
|
+
function clampUntil(now, waitMs) {
|
|
26221
|
+
const wait = Math.min(Math.max(waitMs, MIN_LIMIT_WAIT_MS), MAX_LIMIT_WAIT_MS);
|
|
26222
|
+
return new Date(now.getTime() + wait);
|
|
26223
|
+
}
|
|
26224
|
+
function retryAfterMs(value, now) {
|
|
26225
|
+
if (value === null) return null;
|
|
26226
|
+
const trimmed = value.trim();
|
|
26227
|
+
if (/^\d+(\.\d+)?$/.test(trimmed)) return Number(trimmed) * 1e3;
|
|
26228
|
+
const at2 = Date.parse(trimmed);
|
|
26229
|
+
return Number.isFinite(at2) ? at2 - now.getTime() : null;
|
|
26230
|
+
}
|
|
26231
|
+
function durationMs(value) {
|
|
26232
|
+
if (value === null) return null;
|
|
26233
|
+
const trimmed = value.trim();
|
|
26234
|
+
if (trimmed.length === 0) return null;
|
|
26235
|
+
const units = {
|
|
26236
|
+
h: 36e5,
|
|
26237
|
+
m: 6e4,
|
|
26238
|
+
s: 1e3,
|
|
26239
|
+
ms: 1
|
|
26240
|
+
};
|
|
26241
|
+
let total2 = 0;
|
|
26242
|
+
let rest = trimmed;
|
|
26243
|
+
while (rest.length > 0) {
|
|
26244
|
+
const match = /^(\d+(?:\.\d+)?)(ms|h|m|s)/.exec(rest);
|
|
26245
|
+
if (!match) return null;
|
|
26246
|
+
total2 += Number(match[1]) * units[match[2]];
|
|
26247
|
+
rest = rest.slice(match[0].length);
|
|
26248
|
+
}
|
|
26249
|
+
return total2;
|
|
26250
|
+
}
|
|
26251
|
+
function latestResetMs(headers, names2, now) {
|
|
26252
|
+
let latest2 = null;
|
|
26253
|
+
for (const name2 of names2) {
|
|
26254
|
+
const at2 = Date.parse(headers.get(name2) ?? "");
|
|
26255
|
+
if (!Number.isFinite(at2)) continue;
|
|
26256
|
+
const wait = at2 - now.getTime();
|
|
26257
|
+
if (latest2 === null || wait > latest2) latest2 = wait;
|
|
26258
|
+
}
|
|
26259
|
+
return latest2;
|
|
26260
|
+
}
|
|
26261
|
+
function longestDurationMs(headers, names2) {
|
|
26262
|
+
let longest = null;
|
|
26263
|
+
for (const name2 of names2) {
|
|
26264
|
+
const wait = durationMs(headers.get(name2));
|
|
26265
|
+
if (wait !== null && (longest === null || wait > longest)) longest = wait;
|
|
26266
|
+
}
|
|
26267
|
+
return longest;
|
|
26268
|
+
}
|
|
26269
|
+
function errorOf(body2) {
|
|
26270
|
+
if (body2 === null) return null;
|
|
26271
|
+
let parsed2;
|
|
26272
|
+
try {
|
|
26273
|
+
parsed2 = JSON.parse(body2);
|
|
26274
|
+
} catch {
|
|
26275
|
+
return null;
|
|
26276
|
+
}
|
|
26277
|
+
if (parsed2 === null || typeof parsed2 !== "object") return null;
|
|
26278
|
+
const error2 = parsed2.error;
|
|
26279
|
+
return error2 !== null && typeof error2 === "object" ? error2 : null;
|
|
26280
|
+
}
|
|
26281
|
+
function stringField(error2, key) {
|
|
26282
|
+
const value = error2?.[key];
|
|
26283
|
+
return typeof value === "string" ? value : null;
|
|
26284
|
+
}
|
|
26285
|
+
function numberField(error2, key) {
|
|
26286
|
+
const value = error2?.[key];
|
|
26287
|
+
return typeof value === "number" && Number.isFinite(value) ? value : null;
|
|
26288
|
+
}
|
|
26289
|
+
function namesShutAccount(error2) {
|
|
26290
|
+
const message2 = stringField(error2, "message");
|
|
26291
|
+
if (message2 === null) return false;
|
|
26292
|
+
return message2.toLowerCase().split(/(?<=[.!?])\s+/).some(
|
|
26293
|
+
(sentence2) => SHUT_ACCOUNT_PHRASES.some(
|
|
26294
|
+
(phrase) => sentence2.trimStart().startsWith(phrase)
|
|
26295
|
+
)
|
|
26296
|
+
);
|
|
26297
|
+
}
|
|
26298
|
+
function anthropicFailure(status2, headers, body2, now) {
|
|
26299
|
+
const error2 = errorOf(body2);
|
|
26300
|
+
if (status2 === 401) return INVALID_TOKEN;
|
|
26301
|
+
if (status2 === 403) return namesShutAccount(error2) ? DEACTIVATED : null;
|
|
26302
|
+
if (status2 === 400) {
|
|
26303
|
+
if (stringField(error2, "type") !== "invalid_request_error") return null;
|
|
26304
|
+
const message2 = stringField(error2, "message")?.toLowerCase() ?? "";
|
|
26305
|
+
if (message2.includes("credit balance")) {
|
|
26306
|
+
return {
|
|
26307
|
+
kind: "credit_exhausted",
|
|
26308
|
+
until: clampUntil(now, DEFAULT_LIMIT_WAIT_MS.credit_exhausted)
|
|
26309
|
+
};
|
|
26310
|
+
}
|
|
26311
|
+
return namesShutAccount(error2) ? DEACTIVATED : null;
|
|
26312
|
+
}
|
|
26313
|
+
if (status2 !== 429) return null;
|
|
26314
|
+
if (headers.get("anthropic-ratelimit-unified-status") === "rejected") {
|
|
26315
|
+
const reset = Number(headers.get("anthropic-ratelimit-unified-reset"));
|
|
26316
|
+
const wait2 = Number.isFinite(reset) && reset > 0 ? reset * 1e3 - now.getTime() : DEFAULT_LIMIT_WAIT_MS.usage_limit;
|
|
26317
|
+
const claim = headers.get("anthropic-ratelimit-unified-representative-claim") ?? "";
|
|
26318
|
+
const modelScoped = /opus|sonnet|haiku/i.test(claim);
|
|
26319
|
+
return {
|
|
26320
|
+
kind: "usage_limit",
|
|
26321
|
+
until: clampUntil(
|
|
26322
|
+
now,
|
|
26323
|
+
modelScoped ? Math.min(wait2, MODEL_SCOPED_HOLD_MS) : wait2
|
|
26324
|
+
)
|
|
26325
|
+
};
|
|
26326
|
+
}
|
|
26327
|
+
const wait = retryAfterMs(headers.get("retry-after"), now) ?? latestResetMs(headers, ANTHROPIC_RESETS, now) ?? DEFAULT_LIMIT_WAIT_MS.rate_limit;
|
|
26328
|
+
return { kind: "rate_limit", until: clampUntil(now, wait) };
|
|
26329
|
+
}
|
|
26330
|
+
function openaiFailure(status2, headers, body2, now) {
|
|
26331
|
+
if (status2 !== 401 && status2 !== 403 && status2 !== 429) return null;
|
|
26332
|
+
const error2 = errorOf(body2);
|
|
26333
|
+
const code = stringField(error2, "code");
|
|
26334
|
+
const type = stringField(error2, "type");
|
|
26335
|
+
if (code !== null && OPENAI_SHUT_CODES.has(code) || type !== null && OPENAI_SHUT_CODES.has(type)) {
|
|
26336
|
+
return DEACTIVATED;
|
|
26337
|
+
}
|
|
26338
|
+
if (status2 === 401) return INVALID_TOKEN;
|
|
26339
|
+
if (status2 === 403) return namesShutAccount(error2) ? DEACTIVATED : null;
|
|
26340
|
+
if (code === "insufficient_quota" || type === "insufficient_quota") {
|
|
26341
|
+
return {
|
|
26342
|
+
kind: "credit_exhausted",
|
|
26343
|
+
until: clampUntil(now, DEFAULT_LIMIT_WAIT_MS.credit_exhausted)
|
|
26344
|
+
};
|
|
26345
|
+
}
|
|
26346
|
+
if (code === "usage_limit_reached" || type === "usage_limit_reached") {
|
|
26347
|
+
const resetsAt = numberField(error2, "resets_at");
|
|
26348
|
+
const resetsIn = numberField(error2, "resets_in_seconds");
|
|
26349
|
+
const wait2 = resetsAt !== null && resetsAt > 0 ? resetsAt * 1e3 - now.getTime() : resetsIn !== null ? resetsIn * 1e3 : DEFAULT_LIMIT_WAIT_MS.usage_limit;
|
|
26350
|
+
return { kind: "usage_limit", until: clampUntil(now, wait2) };
|
|
26351
|
+
}
|
|
26352
|
+
const retryAfterMsHeader = Number(headers.get("retry-after-ms"));
|
|
26353
|
+
const wait = (Number.isFinite(retryAfterMsHeader) && retryAfterMsHeader > 0 ? retryAfterMsHeader : null) ?? retryAfterMs(headers.get("retry-after"), now) ?? longestDurationMs(headers, OPENAI_RESETS) ?? DEFAULT_LIMIT_WAIT_MS.rate_limit;
|
|
26354
|
+
return { kind: "rate_limit", until: clampUntil(now, wait) };
|
|
26355
|
+
}
|
|
26356
|
+
function classifyModelFailure(provider, status2, headers, body2, now) {
|
|
26357
|
+
return provider === "anthropic" ? anthropicFailure(status2, headers, body2, now) : openaiFailure(status2, headers, body2, now);
|
|
26358
|
+
}
|
|
26359
|
+
var MODEL_FAILURE_KINDS, DEFAULT_LIMIT_WAIT_MS, DEAD_CREDENTIAL_HOLD_MS, MODEL_SCOPED_HOLD_MS, MIN_LIMIT_WAIT_MS, MAX_LIMIT_WAIT_MS, MODEL_FAILURE_BODY_MAX_BYTES, SHUT_ACCOUNT_PHRASES, ANTHROPIC_RESETS, OPENAI_RESETS, OPENAI_SHUT_CODES, INVALID_TOKEN, DEACTIVATED;
|
|
26360
|
+
var init_model_failure = __esm({
|
|
26361
|
+
"../../packages/tacho/src/collector/model-failure.ts"() {
|
|
26362
|
+
"use strict";
|
|
26363
|
+
MODEL_FAILURE_KINDS = [
|
|
26364
|
+
"rate_limit",
|
|
26365
|
+
"usage_limit",
|
|
26366
|
+
"credit_exhausted",
|
|
26367
|
+
"invalid_token",
|
|
26368
|
+
"account_deactivated"
|
|
26369
|
+
];
|
|
26370
|
+
DEFAULT_LIMIT_WAIT_MS = Object.freeze({
|
|
26371
|
+
// A subscription's limit that names no reset is held for an hour, then
|
|
26372
|
+
// asked again.
|
|
26373
|
+
usage_limit: 60 * 6e4,
|
|
26374
|
+
rate_limit: 6e4,
|
|
26375
|
+
// Credit comes back only when someone pays, so an hour between asks.
|
|
26376
|
+
credit_exhausted: 60 * 6e4
|
|
26377
|
+
});
|
|
26378
|
+
DEAD_CREDENTIAL_HOLD_MS = 60 * 6e4;
|
|
26379
|
+
MODEL_SCOPED_HOLD_MS = 60 * 6e4;
|
|
26380
|
+
MIN_LIMIT_WAIT_MS = 1e3;
|
|
26381
|
+
MAX_LIMIT_WAIT_MS = 8 * 24 * 60 * 6e4;
|
|
26382
|
+
MODEL_FAILURE_BODY_MAX_BYTES = 64 * 1024;
|
|
26383
|
+
SHUT_ACCOUNT_PHRASES = Object.freeze([
|
|
26384
|
+
...["this", "your"].flatMap(
|
|
26385
|
+
(owner) => ["organization", "account"].flatMap(
|
|
26386
|
+
(holder) => ["disabled", "deactivated", "suspended"].map(
|
|
26387
|
+
(state) => `${owner} ${holder} has been ${state}`
|
|
26388
|
+
)
|
|
26389
|
+
)
|
|
26390
|
+
),
|
|
26391
|
+
"this key is associated with a deactivated account"
|
|
26392
|
+
]);
|
|
26393
|
+
ANTHROPIC_RESETS = [
|
|
26394
|
+
"anthropic-ratelimit-requests-reset",
|
|
26395
|
+
"anthropic-ratelimit-tokens-reset",
|
|
26396
|
+
"anthropic-ratelimit-input-tokens-reset",
|
|
26397
|
+
"anthropic-ratelimit-output-tokens-reset"
|
|
26398
|
+
];
|
|
26399
|
+
OPENAI_RESETS = [
|
|
26400
|
+
"x-ratelimit-reset-requests",
|
|
26401
|
+
"x-ratelimit-reset-tokens"
|
|
26402
|
+
];
|
|
26403
|
+
OPENAI_SHUT_CODES = /* @__PURE__ */ new Set([
|
|
26404
|
+
"account_deactivated",
|
|
26405
|
+
"billing_not_active"
|
|
26406
|
+
]);
|
|
26407
|
+
INVALID_TOKEN = Object.freeze({ kind: "invalid_token" });
|
|
26408
|
+
DEACTIVATED = Object.freeze({
|
|
26409
|
+
kind: "account_deactivated"
|
|
26410
|
+
});
|
|
26411
|
+
}
|
|
26412
|
+
});
|
|
26413
|
+
|
|
26192
26414
|
// ../../packages/tacho/src/host/run-token.ts
|
|
26193
26415
|
import { createHmac, randomBytes as randomBytes4, timingSafeEqual } from "node:crypto";
|
|
26194
26416
|
import { readFileSync as readFileSync6 } from "node:fs";
|
|
@@ -26378,6 +26600,9 @@ import {
|
|
|
26378
26600
|
unlinkSync as unlinkSync4,
|
|
26379
26601
|
writeSync as writeSync3
|
|
26380
26602
|
} from "node:fs";
|
|
26603
|
+
function isLoginKind(kind) {
|
|
26604
|
+
return kind === "oauth" || kind === "chatgpt";
|
|
26605
|
+
}
|
|
26381
26606
|
function anthropicCredentialKind(secret, fallback) {
|
|
26382
26607
|
return secret.trim().startsWith(CLAUDE_OAUTH_TOKEN_PREFIX) ? "oauth" : fallback;
|
|
26383
26608
|
}
|
|
@@ -26390,6 +26615,59 @@ function sealingContext(provider, harness) {
|
|
|
26390
26615
|
function matches(entry2, provider, harness) {
|
|
26391
26616
|
return entry2.provider === provider && harnessOf(entry2) === harness;
|
|
26392
26617
|
}
|
|
26618
|
+
function isVaultCopy(entry2) {
|
|
26619
|
+
return entry2.source === VAULT_POOL_SOURCE;
|
|
26620
|
+
}
|
|
26621
|
+
function memberIdOf(entry2) {
|
|
26622
|
+
return entry2.credential_id ?? HELD_MEMBER_ID;
|
|
26623
|
+
}
|
|
26624
|
+
function entryContext(entry2) {
|
|
26625
|
+
const slot = sealingContext(entry2.provider, harnessOf(entry2));
|
|
26626
|
+
return isVaultCopy(entry2) ? `${slot}:${entry2.credential_id ?? ""}` : slot;
|
|
26627
|
+
}
|
|
26628
|
+
function slotEntries(entries2, provider, harness) {
|
|
26629
|
+
const slot = entries2.filter((e) => matches(e, provider, harness));
|
|
26630
|
+
return [
|
|
26631
|
+
...slot.filter((e) => !isVaultCopy(e)),
|
|
26632
|
+
...slot.filter((e) => isVaultCopy(e))
|
|
26633
|
+
];
|
|
26634
|
+
}
|
|
26635
|
+
function withSlot(entries2, provider, harness, slot) {
|
|
26636
|
+
const first = entries2.findIndex((e) => matches(e, provider, harness));
|
|
26637
|
+
const rest = entries2.filter((e) => !matches(e, provider, harness));
|
|
26638
|
+
if (first < 0) return [...rest, ...slot];
|
|
26639
|
+
const before = entries2.slice(0, first).filter((e) => !matches(e, provider, harness)).length;
|
|
26640
|
+
return [...rest.slice(0, before), ...slot, ...rest.slice(before)];
|
|
26641
|
+
}
|
|
26642
|
+
function hintOf(kind, secret) {
|
|
26643
|
+
if (kind === "chatgpt") {
|
|
26644
|
+
const account = chatGptAccountOf(secret);
|
|
26645
|
+
return account !== void 0 && account.length >= 8 ? account.slice(-4) : void 0;
|
|
26646
|
+
}
|
|
26647
|
+
const trimmed = secret.trim();
|
|
26648
|
+
return trimmed.length >= 8 ? trimmed.slice(-4) : void 0;
|
|
26649
|
+
}
|
|
26650
|
+
function chatGptAccountOf(secret) {
|
|
26651
|
+
let parsed2;
|
|
26652
|
+
try {
|
|
26653
|
+
parsed2 = JSON.parse(secret);
|
|
26654
|
+
} catch {
|
|
26655
|
+
return void 0;
|
|
26656
|
+
}
|
|
26657
|
+
if (parsed2 === null || typeof parsed2 !== "object") return void 0;
|
|
26658
|
+
const account = parsed2["account_id"];
|
|
26659
|
+
return typeof account === "string" && account.length > 0 ? account : void 0;
|
|
26660
|
+
}
|
|
26661
|
+
function identityOf(kind, secret) {
|
|
26662
|
+
if (kind === "chatgpt") {
|
|
26663
|
+
const account = chatGptAccountOf(secret);
|
|
26664
|
+
if (account !== void 0) return `chatgpt:${account}`;
|
|
26665
|
+
}
|
|
26666
|
+
return `${kind === "chatgpt" ? "chatgpt" : "secret"}:${secret.trim()}`;
|
|
26667
|
+
}
|
|
26668
|
+
function heldBackAt(failure4, now) {
|
|
26669
|
+
return failure4 !== void 0 && Date.parse(failure4.until) > now;
|
|
26670
|
+
}
|
|
26393
26671
|
function readKey(path2) {
|
|
26394
26672
|
try {
|
|
26395
26673
|
const hex = readFileSync7(path2, "utf8").trim();
|
|
@@ -26471,6 +26749,40 @@ function custodyOf(entry2) {
|
|
|
26471
26749
|
prefix: entry2.prefix
|
|
26472
26750
|
};
|
|
26473
26751
|
}
|
|
26752
|
+
function memberOf(entry2) {
|
|
26753
|
+
return {
|
|
26754
|
+
id: memberIdOf(entry2),
|
|
26755
|
+
kind: entry2.kind,
|
|
26756
|
+
source: entry2.source,
|
|
26757
|
+
prefix: entry2.prefix,
|
|
26758
|
+
taken_at: entry2.taken_at,
|
|
26759
|
+
...entry2.credential_id !== void 0 ? { credential_id: entry2.credential_id } : {},
|
|
26760
|
+
...entry2.hint !== void 0 ? { hint: entry2.hint } : {},
|
|
26761
|
+
...entry2.label !== void 0 ? { label: entry2.label } : {},
|
|
26762
|
+
...entry2.refreshed_at !== void 0 ? { refreshed_at: entry2.refreshed_at } : {},
|
|
26763
|
+
...entry2.refresh_refused !== void 0 ? { refresh_refused: entry2.refresh_refused } : {},
|
|
26764
|
+
...entry2.failure !== void 0 ? { failure: { ...entry2.failure } } : {}
|
|
26765
|
+
};
|
|
26766
|
+
}
|
|
26767
|
+
function refreshedSince(entry2, vaultChangedAt) {
|
|
26768
|
+
if (entry2.refreshed_at === void 0) return false;
|
|
26769
|
+
const refreshed = Date.parse(entry2.refreshed_at);
|
|
26770
|
+
const changed = Date.parse(vaultChangedAt);
|
|
26771
|
+
return Number.isFinite(refreshed) && Number.isFinite(changed) && refreshed > changed;
|
|
26772
|
+
}
|
|
26773
|
+
function prefixOf(kind, secret) {
|
|
26774
|
+
return kind === "chatgpt" ? "login" : credentialPrefix(secret);
|
|
26775
|
+
}
|
|
26776
|
+
function mergedFailure(local, limitedUntil, now) {
|
|
26777
|
+
if (limitedUntil === void 0 || limitedUntil <= now) return local;
|
|
26778
|
+
if (local !== void 0 && Date.parse(local.until) >= limitedUntil)
|
|
26779
|
+
return local;
|
|
26780
|
+
return {
|
|
26781
|
+
kind: local?.kind ?? "usage_limit",
|
|
26782
|
+
at: new Date(now).toISOString(),
|
|
26783
|
+
until: new Date(limitedUntil).toISOString()
|
|
26784
|
+
};
|
|
26785
|
+
}
|
|
26474
26786
|
function openCredentialStore(paths) {
|
|
26475
26787
|
let entriesSeen;
|
|
26476
26788
|
let keySeen;
|
|
@@ -26531,6 +26843,22 @@ function openCredentialStore(paths) {
|
|
|
26531
26843
|
);
|
|
26532
26844
|
}
|
|
26533
26845
|
const ownerOf = (provider, harness) => harness ?? defaultHarnessForProvider(provider);
|
|
26846
|
+
const openEntry = (entry2) => ({
|
|
26847
|
+
kind: entry2.kind,
|
|
26848
|
+
secret: open(keyForRead(), entry2.sealed, entryContext(entry2))
|
|
26849
|
+
});
|
|
26850
|
+
function updateMember(provider, harness, id2, change) {
|
|
26851
|
+
const entries2 = readAll();
|
|
26852
|
+
const slot = slotEntries(entries2, provider, harness);
|
|
26853
|
+
const at2 = slot.findIndex((e) => memberIdOf(e) === id2);
|
|
26854
|
+
const current = slot[at2];
|
|
26855
|
+
if (current === void 0) return false;
|
|
26856
|
+
const next = change(current);
|
|
26857
|
+
if (next === void 0) return false;
|
|
26858
|
+
const rewritten = slot.map((e, i2) => i2 === at2 ? next : e);
|
|
26859
|
+
writeAll3(withSlot(entries2, provider, harness, rewritten));
|
|
26860
|
+
return true;
|
|
26861
|
+
}
|
|
26534
26862
|
return {
|
|
26535
26863
|
has: (provider, harness) => {
|
|
26536
26864
|
const owner = ownerOf(provider, harness);
|
|
@@ -26538,21 +26866,14 @@ function openCredentialStore(paths) {
|
|
|
26538
26866
|
},
|
|
26539
26867
|
read: (provider, harness) => {
|
|
26540
26868
|
const owner = ownerOf(provider, harness);
|
|
26541
|
-
const entry2 = readAll()
|
|
26542
|
-
|
|
26543
|
-
return {
|
|
26544
|
-
kind: entry2.kind,
|
|
26545
|
-
secret: open(
|
|
26546
|
-
keyForRead(),
|
|
26547
|
-
entry2.sealed,
|
|
26548
|
-
sealingContext(provider, owner)
|
|
26549
|
-
)
|
|
26550
|
-
};
|
|
26869
|
+
const entry2 = slotEntries(readAll(), provider, owner)[0];
|
|
26870
|
+
return entry2 === void 0 ? void 0 : openEntry(entry2);
|
|
26551
26871
|
},
|
|
26552
26872
|
take: (provider, { kind, secret }, source, now, harness) => {
|
|
26553
26873
|
if (secret.trim().length === 0)
|
|
26554
26874
|
throw new Error("refusing to take an empty credential into custody");
|
|
26555
26875
|
const owner = ownerOf(provider, harness);
|
|
26876
|
+
const hint = hintOf(kind, secret);
|
|
26556
26877
|
const entry2 = {
|
|
26557
26878
|
provider,
|
|
26558
26879
|
harness: owner,
|
|
@@ -26560,29 +26881,201 @@ function openCredentialStore(paths) {
|
|
|
26560
26881
|
source,
|
|
26561
26882
|
taken_at: new Date(now).toISOString(),
|
|
26562
26883
|
// A ChatGPT login is JSON, whose head says nothing; it is named.
|
|
26563
|
-
prefix: kind
|
|
26564
|
-
sealed: seal(keyForWrite(), secret, sealingContext(provider, owner))
|
|
26884
|
+
prefix: prefixOf(kind, secret),
|
|
26885
|
+
sealed: seal(keyForWrite(), secret, sealingContext(provider, owner)),
|
|
26886
|
+
...hint !== void 0 ? { hint } : {}
|
|
26565
26887
|
};
|
|
26888
|
+
const entries2 = readAll();
|
|
26889
|
+
const copies = slotEntries(entries2, provider, owner).filter(isVaultCopy);
|
|
26566
26890
|
writeAll3([
|
|
26567
|
-
...
|
|
26568
|
-
entry2
|
|
26891
|
+
...entries2.filter((e) => !matches(e, provider, owner)),
|
|
26892
|
+
entry2,
|
|
26893
|
+
...copies
|
|
26569
26894
|
]);
|
|
26570
26895
|
return custodyOf(entry2);
|
|
26571
26896
|
},
|
|
26572
26897
|
release: (provider, harness) => {
|
|
26573
26898
|
const owner = ownerOf(provider, harness);
|
|
26574
26899
|
const entries2 = readAll();
|
|
26575
|
-
const
|
|
26576
|
-
if (
|
|
26577
|
-
const
|
|
26578
|
-
|
|
26579
|
-
entry2.sealed,
|
|
26580
|
-
sealingContext(provider, owner)
|
|
26581
|
-
);
|
|
26900
|
+
const slot = slotEntries(entries2, provider, owner);
|
|
26901
|
+
if (slot.length === 0) return void 0;
|
|
26902
|
+
const own = slot.find((e) => !isVaultCopy(e));
|
|
26903
|
+
const held = own === void 0 ? void 0 : openEntry(own);
|
|
26582
26904
|
writeAll3(entries2.filter((e) => !matches(e, provider, owner)));
|
|
26583
|
-
return
|
|
26905
|
+
return held;
|
|
26906
|
+
},
|
|
26907
|
+
status: () => {
|
|
26908
|
+
const entries2 = readAll();
|
|
26909
|
+
const seen = /* @__PURE__ */ new Set();
|
|
26910
|
+
const rows = [];
|
|
26911
|
+
for (const entry2 of entries2) {
|
|
26912
|
+
const harness = harnessOf(entry2);
|
|
26913
|
+
const slot = `${entry2.provider}:${harness}`;
|
|
26914
|
+
if (seen.has(slot)) continue;
|
|
26915
|
+
seen.add(slot);
|
|
26916
|
+
const first = slotEntries(entries2, entry2.provider, harness)[0];
|
|
26917
|
+
if (first !== void 0) rows.push(custodyOf(first));
|
|
26918
|
+
}
|
|
26919
|
+
return rows;
|
|
26920
|
+
},
|
|
26921
|
+
pool: (provider, harness) => slotEntries(readAll(), provider, ownerOf(provider, harness)).map(
|
|
26922
|
+
memberOf
|
|
26923
|
+
),
|
|
26924
|
+
open: (provider, harness, id2) => {
|
|
26925
|
+
const entry2 = slotEntries(readAll(), provider, harness).find(
|
|
26926
|
+
(e) => memberIdOf(e) === id2
|
|
26927
|
+
);
|
|
26928
|
+
return entry2 === void 0 ? void 0 : openEntry(entry2);
|
|
26929
|
+
},
|
|
26930
|
+
nextUntried: (provider, harness, options) => {
|
|
26931
|
+
const eligible = slotEntries(readAll(), provider, harness).map(memberOf).filter(
|
|
26932
|
+
(member4) => !(options.tried?.has(member4.id) ?? false) && (options.loginsOnly !== true || isLoginKind(member4.kind)) && (options.fits?.(member4) ?? true)
|
|
26933
|
+
);
|
|
26934
|
+
const ready = eligible.find(
|
|
26935
|
+
(member4) => !heldBackAt(member4.failure, options.now)
|
|
26936
|
+
);
|
|
26937
|
+
if (options.allowHeldBack !== true) return ready;
|
|
26938
|
+
if (ready !== void 0) {
|
|
26939
|
+
const loginReady = eligible.some(
|
|
26940
|
+
(member4) => isLoginKind(member4.kind) && !heldBackAt(member4.failure, options.now)
|
|
26941
|
+
);
|
|
26942
|
+
const waiting = loginReady ? void 0 : eligible.find(
|
|
26943
|
+
(member4) => isLoginKind(member4.kind) && member4.failure?.kind === "rate_limit" && heldBackAt(member4.failure, options.now)
|
|
26944
|
+
);
|
|
26945
|
+
return waiting ?? ready;
|
|
26946
|
+
}
|
|
26947
|
+
let soonest;
|
|
26948
|
+
for (const member4 of eligible) {
|
|
26949
|
+
if (soonest === void 0 || Date.parse(member4.failure?.until ?? "") < Date.parse(soonest.failure?.until ?? ""))
|
|
26950
|
+
soonest = member4;
|
|
26951
|
+
}
|
|
26952
|
+
return soonest;
|
|
26953
|
+
},
|
|
26954
|
+
markFailed: (provider, harness, id2, failure4, now) => updateMember(provider, harness, id2, (entry2) => ({
|
|
26955
|
+
...entry2,
|
|
26956
|
+
...failure4.refreshRefused !== void 0 ? { refresh_refused: failure4.refreshRefused } : {},
|
|
26957
|
+
failure: {
|
|
26958
|
+
kind: failure4.kind,
|
|
26959
|
+
at: new Date(now).toISOString(),
|
|
26960
|
+
until: new Date(failure4.until).toISOString()
|
|
26961
|
+
}
|
|
26962
|
+
})),
|
|
26963
|
+
clearFailure: (provider, harness, id2) => updateMember(provider, harness, id2, (entry2) => {
|
|
26964
|
+
if (entry2.failure === void 0) return void 0;
|
|
26965
|
+
const { failure: _cleared, ...rest } = entry2;
|
|
26966
|
+
return rest;
|
|
26967
|
+
}),
|
|
26968
|
+
replaceSecret: (provider, harness, id2, { kind, secret }, source, now) => {
|
|
26969
|
+
if (secret.trim().length === 0)
|
|
26970
|
+
throw new Error("refusing to take an empty credential into custody");
|
|
26971
|
+
return updateMember(provider, harness, id2, (entry2) => {
|
|
26972
|
+
const { failure: failure4, refresh_refused: _refused, ...rest } = entry2;
|
|
26973
|
+
const at2 = new Date(now).toISOString();
|
|
26974
|
+
const next = {
|
|
26975
|
+
...rest,
|
|
26976
|
+
kind,
|
|
26977
|
+
// A vault copy stays one, so the next sync still knows it; the
|
|
26978
|
+
// machine's own takes the source it was refreshed from.
|
|
26979
|
+
source: isVaultCopy(entry2) ? VAULT_POOL_SOURCE : source,
|
|
26980
|
+
taken_at: at2,
|
|
26981
|
+
refreshed_at: at2,
|
|
26982
|
+
prefix: prefixOf(kind, secret),
|
|
26983
|
+
...failure4 !== void 0 && failure4.kind !== "invalid_token" ? { failure: failure4 } : {},
|
|
26984
|
+
sealed: entry2.sealed
|
|
26985
|
+
};
|
|
26986
|
+
return {
|
|
26987
|
+
...next,
|
|
26988
|
+
sealed: seal(keyForWrite(), secret, entryContext(next))
|
|
26989
|
+
};
|
|
26990
|
+
});
|
|
26991
|
+
},
|
|
26992
|
+
syncPool: (provider, harness, members2, now) => {
|
|
26993
|
+
const entries2 = readAll();
|
|
26994
|
+
const slot = slotEntries(entries2, provider, harness);
|
|
26995
|
+
const own = slot.find((e) => !isVaultCopy(e));
|
|
26996
|
+
if (own === void 0) return { synced: false, reason: "not_brokered" };
|
|
26997
|
+
if (own.source === "sandbox:launch")
|
|
26998
|
+
return { synced: false, reason: "sandbox" };
|
|
26999
|
+
const ownIdentity = identityOf(own.kind, openEntry(own).secret);
|
|
27000
|
+
const local = new Map(
|
|
27001
|
+
slot.filter(isVaultCopy).map((e) => [memberIdOf(e), e])
|
|
27002
|
+
);
|
|
27003
|
+
const identities = /* @__PURE__ */ new Set([ownIdentity]);
|
|
27004
|
+
let ownCopy;
|
|
27005
|
+
const copies = [];
|
|
27006
|
+
let added = 0;
|
|
27007
|
+
let kept = 0;
|
|
27008
|
+
for (const member4 of members2) {
|
|
27009
|
+
if (member4.secret.trim().length === 0) continue;
|
|
27010
|
+
if (!VAULT_CREDENTIAL_ID_PATTERN.test(member4.credential_id)) continue;
|
|
27011
|
+
const identity = identityOf(member4.kind, member4.secret);
|
|
27012
|
+
if (identity === ownIdentity) {
|
|
27013
|
+
ownCopy ??= member4;
|
|
27014
|
+
continue;
|
|
27015
|
+
}
|
|
27016
|
+
if (identities.has(identity)) continue;
|
|
27017
|
+
identities.add(identity);
|
|
27018
|
+
const before = local.get(member4.credential_id);
|
|
27019
|
+
const label = member4.label?.slice(0, 80);
|
|
27020
|
+
const unchanged = before !== void 0 && before.kind === member4.kind && (before.vault_changed_at === member4.changed_at || refreshedSince(before, member4.changed_at));
|
|
27021
|
+
if (before !== void 0) kept += 1;
|
|
27022
|
+
else added += 1;
|
|
27023
|
+
const base2 = unchanged ? { ...before } : {
|
|
27024
|
+
provider,
|
|
27025
|
+
harness,
|
|
27026
|
+
kind: member4.kind,
|
|
27027
|
+
source: VAULT_POOL_SOURCE,
|
|
27028
|
+
taken_at: new Date(now).toISOString(),
|
|
27029
|
+
prefix: prefixOf(member4.kind, member4.secret),
|
|
27030
|
+
credential_id: member4.credential_id,
|
|
27031
|
+
vault_changed_at: member4.changed_at,
|
|
27032
|
+
// Replaced below, once the row's context is known.
|
|
27033
|
+
sealed: own.sealed
|
|
27034
|
+
};
|
|
27035
|
+
const { label: _label, failure: _failure, ...rest } = base2;
|
|
27036
|
+
const failure4 = mergedFailure(
|
|
27037
|
+
unchanged ? before.failure : void 0,
|
|
27038
|
+
member4.limited_until,
|
|
27039
|
+
now
|
|
27040
|
+
);
|
|
27041
|
+
const copy = {
|
|
27042
|
+
...rest,
|
|
27043
|
+
hint: member4.hint.slice(-4),
|
|
27044
|
+
...label !== void 0 && label.length > 0 ? { label } : {},
|
|
27045
|
+
...failure4 !== void 0 ? { failure: failure4 } : {}
|
|
27046
|
+
};
|
|
27047
|
+
copies.push(
|
|
27048
|
+
unchanged ? copy : {
|
|
27049
|
+
...copy,
|
|
27050
|
+
sealed: seal(keyForWrite(), member4.secret, entryContext(copy))
|
|
27051
|
+
}
|
|
27052
|
+
);
|
|
27053
|
+
}
|
|
27054
|
+
const removed = [...local.keys()].filter(
|
|
27055
|
+
(id2) => !members2.some((m) => m.credential_id === id2)
|
|
27056
|
+
).length;
|
|
27057
|
+
const {
|
|
27058
|
+
credential_id: _id,
|
|
27059
|
+
label: _ownLabel,
|
|
27060
|
+
failure: _ownFailure,
|
|
27061
|
+
...ownBare
|
|
27062
|
+
} = own;
|
|
27063
|
+
const ownLabel = ownCopy?.label?.slice(0, 80);
|
|
27064
|
+
const ownFailure = mergedFailure(
|
|
27065
|
+
own.failure,
|
|
27066
|
+
ownCopy?.limited_until,
|
|
27067
|
+
now
|
|
27068
|
+
);
|
|
27069
|
+
const ownNext = {
|
|
27070
|
+
...ownBare,
|
|
27071
|
+
...ownCopy !== void 0 ? { credential_id: ownCopy.credential_id } : {},
|
|
27072
|
+
...ownLabel !== void 0 && ownLabel.length > 0 ? { label: ownLabel } : {},
|
|
27073
|
+
...own.hint === void 0 && ownCopy !== void 0 ? { hint: ownCopy.hint.slice(-4) } : {},
|
|
27074
|
+
...ownFailure !== void 0 ? { failure: ownFailure } : {}
|
|
27075
|
+
};
|
|
27076
|
+
writeAll3(withSlot(entries2, provider, harness, [ownNext, ...copies]));
|
|
27077
|
+
return { synced: true, added, kept, removed };
|
|
26584
27078
|
},
|
|
26585
|
-
status: () => readAll().map(custodyOf),
|
|
26586
27079
|
shred: () => {
|
|
26587
27080
|
let overwrite;
|
|
26588
27081
|
try {
|
|
@@ -26601,11 +27094,12 @@ function openCredentialStore(paths) {
|
|
|
26601
27094
|
}
|
|
26602
27095
|
};
|
|
26603
27096
|
}
|
|
26604
|
-
var CREDENTIAL_STORE_SCHEMA, CREDENTIAL_SOURCES, CREDENTIAL_KINDS, CLAUDE_OAUTH_TOKEN_PREFIX, sealedSchema, entrySchema, fileSchema, KEY_BYTES2;
|
|
27097
|
+
var CREDENTIAL_STORE_SCHEMA, CREDENTIAL_SOURCES, VAULT_POOL_SOURCE, HELD_MEMBER_ID, CREDENTIAL_KINDS, CLAUDE_OAUTH_TOKEN_PREFIX, LOGIN_REFRESH_REFUSALS, sealedSchema, failureSchema, entrySchema, fileSchema, KEY_BYTES2;
|
|
26605
27098
|
var init_credential_store = __esm({
|
|
26606
27099
|
"../../packages/tacho/src/host/credential-store.ts"() {
|
|
26607
27100
|
"use strict";
|
|
26608
27101
|
init_zod();
|
|
27102
|
+
init_model_failure();
|
|
26609
27103
|
init_wire();
|
|
26610
27104
|
init_fs();
|
|
26611
27105
|
init_run_token();
|
|
@@ -26634,8 +27128,15 @@ var init_credential_store = __esm({
|
|
|
26634
27128
|
* is spent at the cloud gateway, which attaches the operator's model
|
|
26635
27129
|
* credential. It is not a model credential itself.
|
|
26636
27130
|
*/
|
|
26637
|
-
"sandbox:launch"
|
|
27131
|
+
"sandbox:launch",
|
|
27132
|
+
/**
|
|
27133
|
+
* One of the person's credentials saved in Oxagen, copied from the vault
|
|
27134
|
+
* by a pool sync (`list_host_model_credentials`).
|
|
27135
|
+
*/
|
|
27136
|
+
"vault:pool"
|
|
26638
27137
|
];
|
|
27138
|
+
VAULT_POOL_SOURCE = "vault:pool";
|
|
27139
|
+
HELD_MEMBER_ID = "held";
|
|
26639
27140
|
CREDENTIAL_KINDS = [
|
|
26640
27141
|
"api_key",
|
|
26641
27142
|
"bearer",
|
|
@@ -26643,12 +27144,20 @@ var init_credential_store = __esm({
|
|
|
26643
27144
|
"chatgpt"
|
|
26644
27145
|
];
|
|
26645
27146
|
CLAUDE_OAUTH_TOKEN_PREFIX = "sk-ant-oat";
|
|
27147
|
+
LOGIN_REFRESH_REFUSALS = ["rotated", "refused"];
|
|
26646
27148
|
sealedSchema = external_exports.object({
|
|
26647
27149
|
/** AES-256-GCM: 12-byte nonce, ciphertext, 16-byte tag, all base64. */
|
|
26648
27150
|
nonce: external_exports.string().min(1),
|
|
26649
27151
|
ciphertext: external_exports.string().min(1),
|
|
26650
27152
|
tag: external_exports.string().min(1)
|
|
26651
27153
|
}).strict();
|
|
27154
|
+
failureSchema = external_exports.object({
|
|
27155
|
+
kind: external_exports.enum(MODEL_FAILURE_KINDS),
|
|
27156
|
+
/** When the provider answered, ISO-8601. */
|
|
27157
|
+
at: external_exports.string(),
|
|
27158
|
+
/** When the gateway asks it again, ISO-8601. */
|
|
27159
|
+
until: external_exports.string()
|
|
27160
|
+
}).strict();
|
|
26652
27161
|
entrySchema = external_exports.object({
|
|
26653
27162
|
provider: external_exports.enum(RUN_TOKEN_PROVIDERS),
|
|
26654
27163
|
/**
|
|
@@ -26662,7 +27171,34 @@ var init_credential_store = __esm({
|
|
|
26662
27171
|
taken_at: external_exports.string(),
|
|
26663
27172
|
/** The first few characters, the way a vendor console shows a key. */
|
|
26664
27173
|
prefix: external_exports.string().max(12),
|
|
26665
|
-
sealed: sealedSchema
|
|
27174
|
+
sealed: sealedSchema,
|
|
27175
|
+
/**
|
|
27176
|
+
* The vault's id for this credential, when the vault holds it: every
|
|
27177
|
+
* `vault:pool` member, and the machine's own credential when the person
|
|
27178
|
+
* saved the same one in Oxagen.
|
|
27179
|
+
*/
|
|
27180
|
+
credential_id: external_exports.string().regex(VAULT_CREDENTIAL_ID_PATTERN).optional(),
|
|
27181
|
+
/** The secret's last four characters, for a message that names it. */
|
|
27182
|
+
hint: external_exports.string().max(4).optional(),
|
|
27183
|
+
/** The name the person gave it in Oxagen, such as the account's email. */
|
|
27184
|
+
label: external_exports.string().max(80).optional(),
|
|
27185
|
+
/**
|
|
27186
|
+
* When the vault last changed the secret, for a `vault:pool` member. A
|
|
27187
|
+
* ChatGPT login this machine refreshed after that time keeps its own,
|
|
27188
|
+
* newer tokens on the next sync.
|
|
27189
|
+
*/
|
|
27190
|
+
vault_changed_at: external_exports.string().optional(),
|
|
27191
|
+
/** When this machine last refreshed the secret (`replaceSecret`), ISO-8601. */
|
|
27192
|
+
refreshed_at: external_exports.string().optional(),
|
|
27193
|
+
/**
|
|
27194
|
+
* The OpenAI issuer refused to refresh the tokens this row holds:
|
|
27195
|
+
* `rotated` when another machine already used the refresh token, and
|
|
27196
|
+
* `refused` for any other refusal. No refresh is asked for again until
|
|
27197
|
+
* the secret changes, because a refresh token sent twice can make the
|
|
27198
|
+
* issuer revoke the login on every machine.
|
|
27199
|
+
*/
|
|
27200
|
+
refresh_refused: external_exports.enum(LOGIN_REFRESH_REFUSALS).optional(),
|
|
27201
|
+
failure: failureSchema.optional()
|
|
26666
27202
|
}).strict();
|
|
26667
27203
|
fileSchema = external_exports.object({
|
|
26668
27204
|
schema: external_exports.literal(CREDENTIAL_STORE_SCHEMA),
|
|
@@ -28624,14 +29160,35 @@ async function credentialStatus(options, deps) {
|
|
|
28624
29160
|
deps,
|
|
28625
29161
|
...others.map((agent) => depsForAgent(deps, agent))
|
|
28626
29162
|
].flatMap(
|
|
28627
|
-
(agent) => (agent.credentialStore?.status() ?? []).map((c) =>
|
|
28628
|
-
|
|
28629
|
-
|
|
28630
|
-
|
|
28631
|
-
|
|
28632
|
-
|
|
28633
|
-
|
|
28634
|
-
|
|
29163
|
+
(agent) => (agent.credentialStore?.status() ?? []).map((c) => {
|
|
29164
|
+
const members2 = agent.credentialStore?.pool(c.provider, c.harness) ?? [];
|
|
29165
|
+
const now = deps.now();
|
|
29166
|
+
const shown3 = members2.length > 1 || members2.some(
|
|
29167
|
+
(m) => m.failure !== void 0 && Date.parse(m.failure.until) > now
|
|
29168
|
+
);
|
|
29169
|
+
return {
|
|
29170
|
+
provider: c.provider,
|
|
29171
|
+
harness: c.harness,
|
|
29172
|
+
kind: c.kind,
|
|
29173
|
+
source: c.source,
|
|
29174
|
+
taken_at: c.taken_at,
|
|
29175
|
+
prefix: c.prefix,
|
|
29176
|
+
...shown3 ? {
|
|
29177
|
+
pool: members2.map((m) => ({
|
|
29178
|
+
id: m.id,
|
|
29179
|
+
kind: m.kind,
|
|
29180
|
+
...m.hint !== void 0 ? { hint: m.hint } : {},
|
|
29181
|
+
...m.label !== void 0 ? { label: m.label } : {},
|
|
29182
|
+
...m.failure !== void 0 && Date.parse(m.failure.until) > now ? {
|
|
29183
|
+
held_back: {
|
|
29184
|
+
kind: m.failure.kind,
|
|
29185
|
+
until: m.failure.until
|
|
29186
|
+
}
|
|
29187
|
+
} : {}
|
|
29188
|
+
}))
|
|
29189
|
+
} : {}
|
|
29190
|
+
};
|
|
29191
|
+
})
|
|
28635
29192
|
);
|
|
28636
29193
|
const enrolled = host === void 0 && others.length === 0 ? MODEL_CREDENTIAL_HARNESSES : [
|
|
28637
29194
|
...host?.harnesses ?? [],
|
|
@@ -28653,13 +29210,92 @@ async function credentialStatus(options, deps) {
|
|
|
28653
29210
|
deps.out(
|
|
28654
29211
|
"Custody nothing: every harness holds its own model credential and the gateway forwards it"
|
|
28655
29212
|
);
|
|
28656
|
-
for (const entry2 of custody)
|
|
29213
|
+
for (const entry2 of custody) {
|
|
28657
29214
|
deps.out(
|
|
28658
29215
|
`Custody ${entry2.provider}${entry2.harness === defaultHarnessForProvider(entry2.provider) ? "" : ` (${TACHO_HARNESS_LABELS[entry2.harness]})`}: ${entry2.kind} ${entry2.prefix} from ${entry2.source}, taken ${entry2.taken_at}`
|
|
28659
29216
|
);
|
|
29217
|
+
for (const [at2, member4] of (entry2.pool ?? []).entries())
|
|
29218
|
+
deps.out(
|
|
29219
|
+
` ${at2 + 1}. ${member4.hint !== void 0 ? `\u2026${member4.hint}` : member4.id} ${member4.kind}${member4.label !== void 0 ? ` (${member4.label})` : ""}${member4.held_back !== void 0 ? `, held back until ${member4.held_back.until} (${member4.held_back.kind})` : ""}`
|
|
29220
|
+
);
|
|
29221
|
+
}
|
|
28660
29222
|
for (const entry2 of state) deps.out(` ${describeHarness(entry2)}`);
|
|
28661
29223
|
return report;
|
|
28662
29224
|
}
|
|
29225
|
+
function harnessLabel(harness) {
|
|
29226
|
+
return isBrokerableHarness(harness) ? TACHO_HARNESS_LABELS[harness] : harness;
|
|
29227
|
+
}
|
|
29228
|
+
function describePoolSync(line) {
|
|
29229
|
+
const label = harnessLabel(line.harness);
|
|
29230
|
+
if (line.synced) {
|
|
29231
|
+
const held = (line.added ?? 0) + (line.kept ?? 0);
|
|
29232
|
+
return `${label}: ${held} saved credential${held === 1 ? "" : "s"} after this machine's own (${line.added ?? 0} added, ${line.removed ?? 0} removed)`;
|
|
29233
|
+
}
|
|
29234
|
+
if (line.reason === "not_brokered")
|
|
29235
|
+
return `${label}: holds its own credential, so the gateway uses no saved one (run \`oxagen agent enroll\` to broker it)`;
|
|
29236
|
+
if (line.reason === "sandbox")
|
|
29237
|
+
return `${label}: a sandbox's calls use the cloud gateway's credentials`;
|
|
29238
|
+
return `${label}: not synced, so custody keeps what it held: ${line.detail ?? "the daemon gave no reason"}`;
|
|
29239
|
+
}
|
|
29240
|
+
async function syncCredentialPoolsNow(deps) {
|
|
29241
|
+
const read2 = readHostFileLenient(deps.paths.hostFile);
|
|
29242
|
+
if (read2.error !== void 0)
|
|
29243
|
+
return {
|
|
29244
|
+
ok: false,
|
|
29245
|
+
detail: `${read2.error}, so nothing was synced. Run \`oxagen agent status\` to see what is wrong with it`,
|
|
29246
|
+
pools: []
|
|
29247
|
+
};
|
|
29248
|
+
const others = otherLiveAgents(deps.paths, deps.paths.dir);
|
|
29249
|
+
if (read2.host === void 0 && others.length === 0)
|
|
29250
|
+
return {
|
|
29251
|
+
ok: false,
|
|
29252
|
+
detail: "this machine is not enrolled; run `oxagen agent enroll`",
|
|
29253
|
+
pools: []
|
|
29254
|
+
};
|
|
29255
|
+
const agents = [
|
|
29256
|
+
...read2.host !== void 0 ? [deps] : [],
|
|
29257
|
+
...others.map((agent) => depsForAgent(deps, agent))
|
|
29258
|
+
];
|
|
29259
|
+
const pools = [];
|
|
29260
|
+
let answered = 0;
|
|
29261
|
+
for (const agent of agents) {
|
|
29262
|
+
const answer = await agent.daemonPost?.("/credential/sync", {});
|
|
29263
|
+
if (answer === void 0 || answer.status !== 200) continue;
|
|
29264
|
+
let body2;
|
|
29265
|
+
try {
|
|
29266
|
+
body2 = JSON.parse(answer.body);
|
|
29267
|
+
} catch {
|
|
29268
|
+
continue;
|
|
29269
|
+
}
|
|
29270
|
+
const parsed2 = poolSyncAnswerSchema.safeParse(body2);
|
|
29271
|
+
if (!parsed2.success) continue;
|
|
29272
|
+
answered += 1;
|
|
29273
|
+
pools.push(...parsed2.data.pools);
|
|
29274
|
+
}
|
|
29275
|
+
if (answered === 0)
|
|
29276
|
+
return {
|
|
29277
|
+
ok: false,
|
|
29278
|
+
detail: "the recorder's daemon did not answer, so nothing was synced. It syncs by itself when it starts; run `oxagen agent status`",
|
|
29279
|
+
pools
|
|
29280
|
+
};
|
|
29281
|
+
return {
|
|
29282
|
+
ok: pools.every((line) => line.synced || line.reason !== "fetch_failed"),
|
|
29283
|
+
pools
|
|
29284
|
+
};
|
|
29285
|
+
}
|
|
29286
|
+
async function credentialSync(options, deps) {
|
|
29287
|
+
const outcome = await syncCredentialPoolsNow(deps);
|
|
29288
|
+
if (options.json === true) {
|
|
29289
|
+
deps.out(JSON.stringify(outcome, null, 2));
|
|
29290
|
+
return outcome;
|
|
29291
|
+
}
|
|
29292
|
+
if (outcome.detail !== void 0) deps.err(outcome.detail);
|
|
29293
|
+
for (const line of outcome.pools)
|
|
29294
|
+
(line.reason === "fetch_failed" ? deps.err : deps.out)(
|
|
29295
|
+
describePoolSync(line)
|
|
29296
|
+
);
|
|
29297
|
+
return outcome;
|
|
29298
|
+
}
|
|
28663
29299
|
function describeHarness(entry2) {
|
|
28664
29300
|
const label = TACHO_HARNESS_LABELS[entry2.harness];
|
|
28665
29301
|
if (entry2.brokered) {
|
|
@@ -29125,10 +29761,11 @@ async function credentialLogin(options, deps) {
|
|
|
29125
29761
|
detail: outcome.harnesses.some((h) => h.brokered) ? "Claude Code now holds a run token, and the gateway sends your subscription with every call" : "The subscription is in custody. Run `oxagen agent enroll` to route Claude Code through the gateway"
|
|
29126
29762
|
};
|
|
29127
29763
|
}
|
|
29128
|
-
var MODEL_CREDENTIAL_HARNESSES, CREDENTIAL_MODES, STELLA_ANTHROPIC_KEY_ENV, CLAUDE_OAUTH_TOKEN_ENV;
|
|
29764
|
+
var MODEL_CREDENTIAL_HARNESSES, CREDENTIAL_MODES, poolSyncAnswerSchema, STELLA_ANTHROPIC_KEY_ENV, CLAUDE_OAUTH_TOKEN_ENV;
|
|
29129
29765
|
var init_credential = __esm({
|
|
29130
29766
|
"../../packages/tacho/src/cli/credential.ts"() {
|
|
29131
29767
|
"use strict";
|
|
29768
|
+
init_zod();
|
|
29132
29769
|
init_claude_setup_token();
|
|
29133
29770
|
init_credential_store();
|
|
29134
29771
|
init_host_file();
|
|
@@ -29140,6 +29777,19 @@ var init_credential = __esm({
|
|
|
29140
29777
|
...BROKERABLE_HARNESSES
|
|
29141
29778
|
];
|
|
29142
29779
|
CREDENTIAL_MODES = ["brokered", "passthrough"];
|
|
29780
|
+
poolSyncAnswerSchema = external_exports.object({
|
|
29781
|
+
pools: external_exports.array(
|
|
29782
|
+
external_exports.object({
|
|
29783
|
+
harness: external_exports.string(),
|
|
29784
|
+
synced: external_exports.boolean(),
|
|
29785
|
+
reason: external_exports.string().optional(),
|
|
29786
|
+
detail: external_exports.string().optional(),
|
|
29787
|
+
added: external_exports.number().optional(),
|
|
29788
|
+
kept: external_exports.number().optional(),
|
|
29789
|
+
removed: external_exports.number().optional()
|
|
29790
|
+
}).passthrough()
|
|
29791
|
+
)
|
|
29792
|
+
});
|
|
29143
29793
|
STELLA_ANTHROPIC_KEY_ENV = "ANTHROPIC_API_KEY";
|
|
29144
29794
|
CLAUDE_OAUTH_TOKEN_ENV = "CLAUDE_CODE_OAUTH_TOKEN";
|
|
29145
29795
|
}
|
|
@@ -29915,7 +30565,7 @@ import { readFileSync as readFileSync10 } from "node:fs";
|
|
|
29915
30565
|
import { dirname as dirname9, resolve as resolve3 } from "node:path";
|
|
29916
30566
|
import { fileURLToPath } from "node:url";
|
|
29917
30567
|
function readVersion() {
|
|
29918
|
-
if (true) return "3.0.1-
|
|
30568
|
+
if (true) return "3.0.1-818";
|
|
29919
30569
|
try {
|
|
29920
30570
|
const here = dirname9(fileURLToPath(import.meta.url));
|
|
29921
30571
|
const pkg = JSON.parse(
|
|
@@ -31289,7 +31939,9 @@ function workOrderEndpointsFor(apiUrl) {
|
|
|
31289
31939
|
workCriterionClaim: `${base2}${WORK_CRITERION_CLAIM_PATH}`,
|
|
31290
31940
|
workOrderProgress: `${base2}${WORK_ORDER_PROGRESS_PATH}`,
|
|
31291
31941
|
certificate: `${base2}${CERTIFICATE_RENEW_PATH}`,
|
|
31292
|
-
enrollmentKeys: `${base2}${ENROLLMENT_KEYS_PATH}
|
|
31942
|
+
enrollmentKeys: `${base2}${ENROLLMENT_KEYS_PATH}`,
|
|
31943
|
+
modelCredentials: `${base2}${HOST_MODEL_CREDENTIALS_PATH}`,
|
|
31944
|
+
modelCredentialState: `${base2}${HOST_MODEL_CREDENTIAL_STATE_PATH}`
|
|
31293
31945
|
};
|
|
31294
31946
|
}
|
|
31295
31947
|
function createControlClient(options) {
|
|
@@ -31414,6 +32066,23 @@ function createControlClient(options) {
|
|
|
31414
32066
|
void 0,
|
|
31415
32067
|
"GET"
|
|
31416
32068
|
),
|
|
32069
|
+
modelCredentials: async (harness) => call2(
|
|
32070
|
+
endpoint(options.endpoints.modelCredentials, "model credentials"),
|
|
32071
|
+
hostModelCredentialsResponseSchema,
|
|
32072
|
+
{ host_enrollment_id: options.hostEnrollmentId, harness }
|
|
32073
|
+
),
|
|
32074
|
+
reportModelCredential: async (credentialId, report) => call2(
|
|
32075
|
+
endpoint(
|
|
32076
|
+
options.endpoints.modelCredentialState,
|
|
32077
|
+
"model credential report"
|
|
32078
|
+
),
|
|
32079
|
+
hostModelCredentialStateResponseSchema,
|
|
32080
|
+
{
|
|
32081
|
+
host_enrollment_id: options.hostEnrollmentId,
|
|
32082
|
+
credential_id: credentialId,
|
|
32083
|
+
report
|
|
32084
|
+
}
|
|
32085
|
+
),
|
|
31417
32086
|
// The body names exactly the contract's fields. It carries no enrollment
|
|
31418
32087
|
// id: the server reads the host from the key. The run's token goes in a
|
|
31419
32088
|
// header, so it stays out of the input the kernel hashes and audits.
|
|
@@ -37815,6 +38484,16 @@ ${problems.map((problem) => ` ${problem}`).join("\n")}`
|
|
|
37815
38484
|
` ${harness === "stella" ? "Stella's " : ""}${provider} credential taken into the gateway's custody (${deps.paths.credentials})`
|
|
37816
38485
|
);
|
|
37817
38486
|
warnings.push(...outcome.warnings);
|
|
38487
|
+
try {
|
|
38488
|
+
const pools = await syncCredentialPoolsNow(deps);
|
|
38489
|
+
for (const line of pools.pools)
|
|
38490
|
+
if (line.synced && (line.added ?? 0) + (line.kept ?? 0) > 0)
|
|
38491
|
+
deps.out(` ${describePoolSync(line)}`);
|
|
38492
|
+
} catch (error2) {
|
|
38493
|
+
warnings.push(
|
|
38494
|
+
`the model credentials saved in Oxagen were not synced yet: ${error2 instanceof Error ? error2.message : String(error2)}. The daemon syncs them when it starts, or run \`oxagen credential sync\``
|
|
38495
|
+
);
|
|
38496
|
+
}
|
|
37818
38497
|
const unrouted = writable2.filter((h) => !reaching.includes(h));
|
|
37819
38498
|
if (unrouted.length > 0) {
|
|
37820
38499
|
const given = await restoreCredentials(
|
|
@@ -41047,7 +41726,7 @@ function createMcpGateway(deps) {
|
|
|
41047
41726
|
return response;
|
|
41048
41727
|
}
|
|
41049
41728
|
};
|
|
41050
|
-
function recordCall(request3, context, status2,
|
|
41729
|
+
function recordCall(request3, context, status2, durationMs2, refusedReason, rpc) {
|
|
41051
41730
|
if (deps.record === void 0) return;
|
|
41052
41731
|
const isCall = request3.method === "tools/call";
|
|
41053
41732
|
if (!isCall && status2 !== "rejected") return;
|
|
@@ -41064,7 +41743,7 @@ function createMcpGateway(deps) {
|
|
|
41064
41743
|
...isCall && request3.params?.["arguments"] !== void 0 ? { arguments: request3.params["arguments"] } : {},
|
|
41065
41744
|
...toolUseId === void 0 ? {} : { toolUseId },
|
|
41066
41745
|
status: status2,
|
|
41067
|
-
durationMs,
|
|
41746
|
+
durationMs: durationMs2,
|
|
41068
41747
|
...refusedReason === void 0 ? {} : { refusedReason },
|
|
41069
41748
|
...ruleIds === void 0 ? {} : { ruleIds },
|
|
41070
41749
|
...taint === void 0 ? {} : { taint },
|
|
@@ -43570,67 +44249,359 @@ function chatGptLoginDue(login, takenAt, now) {
|
|
|
43570
44249
|
if (exp !== void 0) return exp - now < CHATGPT_REFRESH_MARGIN_MS;
|
|
43571
44250
|
return now - takenAt > CHATGPT_REFRESH_MAX_AGE_MS;
|
|
43572
44251
|
}
|
|
43573
|
-
|
|
44252
|
+
function refusalCode(text6) {
|
|
44253
|
+
let parsed2;
|
|
44254
|
+
try {
|
|
44255
|
+
parsed2 = JSON.parse(text6);
|
|
44256
|
+
} catch {
|
|
44257
|
+
return void 0;
|
|
44258
|
+
}
|
|
44259
|
+
if (parsed2 === null || typeof parsed2 !== "object") return void 0;
|
|
44260
|
+
const body2 = parsed2;
|
|
44261
|
+
const error2 = body2["error"];
|
|
44262
|
+
if (typeof error2 === "string") return error2;
|
|
44263
|
+
if (error2 !== null && typeof error2 === "object") {
|
|
44264
|
+
const code = error2["code"];
|
|
44265
|
+
if (typeof code === "string") return code;
|
|
44266
|
+
}
|
|
44267
|
+
const topCode = body2["code"];
|
|
44268
|
+
return typeof topCode === "string" ? topCode : void 0;
|
|
44269
|
+
}
|
|
44270
|
+
async function exchange(login, fetchImpl, timeoutMs) {
|
|
43574
44271
|
if (login.refresh_token.length === 0)
|
|
43575
|
-
|
|
43576
|
-
|
|
43577
|
-
|
|
43578
|
-
|
|
43579
|
-
|
|
43580
|
-
|
|
43581
|
-
|
|
43582
|
-
|
|
43583
|
-
|
|
43584
|
-
|
|
43585
|
-
|
|
43586
|
-
|
|
43587
|
-
|
|
43588
|
-
|
|
43589
|
-
|
|
44272
|
+
return {
|
|
44273
|
+
outcome: "refused",
|
|
44274
|
+
detail: `the ChatGPT login in custody has no refresh token; ${RELOGIN}`
|
|
44275
|
+
};
|
|
44276
|
+
let status2;
|
|
44277
|
+
let ok;
|
|
44278
|
+
let text6;
|
|
44279
|
+
try {
|
|
44280
|
+
const response = await fetchImpl(CHATGPT_TOKEN_URL, {
|
|
44281
|
+
method: "POST",
|
|
44282
|
+
headers: { "Content-Type": "application/json" },
|
|
44283
|
+
body: JSON.stringify({
|
|
44284
|
+
client_id: CODEX_OAUTH_CLIENT_ID,
|
|
44285
|
+
grant_type: "refresh_token",
|
|
44286
|
+
refresh_token: login.refresh_token,
|
|
44287
|
+
scope: "openid profile email"
|
|
44288
|
+
}),
|
|
44289
|
+
signal: AbortSignal.timeout(timeoutMs)
|
|
44290
|
+
});
|
|
44291
|
+
status2 = response.status;
|
|
44292
|
+
ok = response.ok;
|
|
44293
|
+
text6 = await response.text();
|
|
44294
|
+
} catch (error2) {
|
|
44295
|
+
return {
|
|
44296
|
+
outcome: "failed",
|
|
44297
|
+
detail: `could not reach auth.openai.com: ${error2 instanceof Error ? error2.message : String(error2)}`
|
|
44298
|
+
};
|
|
44299
|
+
}
|
|
44300
|
+
if (!ok) {
|
|
44301
|
+
if (status2 === 429 || status2 >= 500)
|
|
44302
|
+
return {
|
|
44303
|
+
outcome: "failed",
|
|
44304
|
+
detail: `auth.openai.com answered ${status2} to a refresh`
|
|
44305
|
+
};
|
|
44306
|
+
const code = refusalCode(text6);
|
|
44307
|
+
return {
|
|
44308
|
+
outcome: code !== void 0 && ROTATED_REFRESH_CODES.has(code) ? "rotated" : "refused",
|
|
44309
|
+
detail: `auth.openai.com refused to refresh the ChatGPT login (${status2}${code !== void 0 ? `, ${code.slice(0, 64)}` : ""}); ${RELOGIN}`
|
|
44310
|
+
};
|
|
44311
|
+
}
|
|
43590
44312
|
let body2;
|
|
43591
44313
|
try {
|
|
43592
|
-
body2 = JSON.parse(
|
|
44314
|
+
body2 = JSON.parse(text6);
|
|
43593
44315
|
} catch {
|
|
43594
|
-
|
|
44316
|
+
return {
|
|
44317
|
+
outcome: "failed",
|
|
44318
|
+
detail: "auth.openai.com answered with something other than JSON"
|
|
44319
|
+
};
|
|
43595
44320
|
}
|
|
43596
44321
|
if (typeof body2.access_token !== "string" || body2.access_token.length === 0)
|
|
43597
|
-
|
|
44322
|
+
return {
|
|
44323
|
+
outcome: "failed",
|
|
44324
|
+
detail: "auth.openai.com answered without an access token"
|
|
44325
|
+
};
|
|
43598
44326
|
return {
|
|
43599
|
-
|
|
43600
|
-
|
|
43601
|
-
|
|
43602
|
-
|
|
43603
|
-
|
|
43604
|
-
}
|
|
43605
|
-
|
|
43606
|
-
|
|
43607
|
-
|
|
43608
|
-
const
|
|
43609
|
-
const
|
|
43610
|
-
|
|
43611
|
-
|
|
43612
|
-
|
|
43613
|
-
const
|
|
43614
|
-
|
|
43615
|
-
|
|
43616
|
-
|
|
44327
|
+
login: {
|
|
44328
|
+
...login,
|
|
44329
|
+
access_token: body2.access_token,
|
|
44330
|
+
refresh_token: typeof body2.refresh_token === "string" ? body2.refresh_token : login.refresh_token,
|
|
44331
|
+
...typeof body2.id_token === "string" ? { id_token: body2.id_token } : {}
|
|
44332
|
+
}
|
|
44333
|
+
};
|
|
44334
|
+
}
|
|
44335
|
+
function createChatGptRefresher(deps) {
|
|
44336
|
+
const { store } = deps;
|
|
44337
|
+
const timeoutMs = deps.timeoutMs ?? CHATGPT_REFRESH_TIMEOUT_MS;
|
|
44338
|
+
const running = /* @__PURE__ */ new Map();
|
|
44339
|
+
const memberOf2 = (id2) => store.pool(...SLOT).find((member4) => member4.id === id2);
|
|
44340
|
+
async function refreshOnce(id2) {
|
|
44341
|
+
const member4 = memberOf2(id2);
|
|
44342
|
+
if (member4 === void 0 || member4.kind !== "chatgpt")
|
|
44343
|
+
return {
|
|
44344
|
+
outcome: "failed",
|
|
44345
|
+
detail: "custody holds no such ChatGPT login"
|
|
44346
|
+
};
|
|
44347
|
+
if (member4.refresh_refused !== void 0)
|
|
44348
|
+
return {
|
|
44349
|
+
outcome: member4.refresh_refused,
|
|
44350
|
+
detail: `auth.openai.com already refused to refresh these tokens; ${RELOGIN}`
|
|
44351
|
+
};
|
|
44352
|
+
const held = store.open(...SLOT, id2);
|
|
44353
|
+
const login = held?.kind === "chatgpt" ? decodeChatGptLogin(held.secret) : void 0;
|
|
44354
|
+
if (login === void 0)
|
|
44355
|
+
return { outcome: "failed", detail: "custody holds no ChatGPT login" };
|
|
44356
|
+
const answer = await exchange(login, deps.fetch, timeoutMs);
|
|
44357
|
+
if (!("login" in answer)) {
|
|
44358
|
+
if (answer.outcome !== "failed")
|
|
44359
|
+
store.markFailed(
|
|
44360
|
+
...SLOT,
|
|
44361
|
+
id2,
|
|
44362
|
+
{
|
|
44363
|
+
kind: "invalid_token",
|
|
44364
|
+
until: deps.now() + DEAD_CREDENTIAL_HOLD_MS,
|
|
44365
|
+
refreshRefused: answer.outcome
|
|
44366
|
+
},
|
|
44367
|
+
deps.now()
|
|
44368
|
+
);
|
|
44369
|
+
return answer;
|
|
44370
|
+
}
|
|
44371
|
+
store.replaceSecret(
|
|
44372
|
+
...SLOT,
|
|
44373
|
+
id2,
|
|
44374
|
+
{ kind: "chatgpt", secret: JSON.stringify(answer.login) },
|
|
43617
44375
|
"chatgpt:refresh",
|
|
43618
|
-
now
|
|
43619
|
-
);
|
|
43620
|
-
|
|
43621
|
-
|
|
43622
|
-
|
|
44376
|
+
deps.now()
|
|
44377
|
+
);
|
|
44378
|
+
deps.refreshed?.(memberOf2(id2) ?? member4);
|
|
44379
|
+
return { outcome: "refreshed" };
|
|
44380
|
+
}
|
|
44381
|
+
function refresh(id2) {
|
|
44382
|
+
const under2 = running.get(id2);
|
|
44383
|
+
if (under2 !== void 0) return under2;
|
|
44384
|
+
const started = refreshOnce(id2).catch(
|
|
44385
|
+
(error2) => ({
|
|
44386
|
+
outcome: "failed",
|
|
44387
|
+
detail: `custody could not be read or written: ${error2 instanceof Error ? error2.message : String(error2)}`
|
|
44388
|
+
})
|
|
44389
|
+
).finally(() => running.delete(id2));
|
|
44390
|
+
running.set(id2, started);
|
|
44391
|
+
return started;
|
|
44392
|
+
}
|
|
44393
|
+
async function refreshDue() {
|
|
44394
|
+
const logins = store.pool(...SLOT).filter((member4) => member4.kind === "chatgpt");
|
|
44395
|
+
if (logins.length === 0) return "none";
|
|
44396
|
+
let refreshed = 0;
|
|
44397
|
+
const failed5 = [];
|
|
44398
|
+
for (const member4 of logins) {
|
|
44399
|
+
const name2 = logins.length === 1 ? "" : `${member4.hint !== void 0 ? `\u2026${member4.hint}` : member4.id}: `;
|
|
44400
|
+
if (member4.refresh_refused !== void 0) continue;
|
|
44401
|
+
const held = store.open(...SLOT, member4.id);
|
|
44402
|
+
const login = held?.kind === "chatgpt" ? decodeChatGptLogin(held.secret) : void 0;
|
|
44403
|
+
if (login === void 0) {
|
|
44404
|
+
failed5.push(`${name2}custody holds no ChatGPT login`);
|
|
44405
|
+
continue;
|
|
44406
|
+
}
|
|
44407
|
+
const due = member4.failure?.kind === "invalid_token" || chatGptLoginDue(login, Date.parse(member4.taken_at), deps.now());
|
|
44408
|
+
if (!due) continue;
|
|
44409
|
+
const result2 = await refresh(member4.id);
|
|
44410
|
+
if (result2.outcome === "refreshed") refreshed += 1;
|
|
44411
|
+
else failed5.push(`${name2}${result2.detail}`);
|
|
44412
|
+
}
|
|
44413
|
+
if (failed5.length > 0) return { failed: failed5.join("; ") };
|
|
44414
|
+
return refreshed > 0 ? "refreshed" : "fresh";
|
|
43623
44415
|
}
|
|
44416
|
+
return { refresh, refreshDue };
|
|
43624
44417
|
}
|
|
43625
|
-
var CODEX_OAUTH_CLIENT_ID, CHATGPT_TOKEN_URL, CHATGPT_REFRESH_MARGIN_MS, CHATGPT_REFRESH_MAX_AGE_MS;
|
|
44418
|
+
var CODEX_OAUTH_CLIENT_ID, CHATGPT_TOKEN_URL, CHATGPT_REFRESH_MARGIN_MS, CHATGPT_REFRESH_MAX_AGE_MS, CHATGPT_REFRESH_TIMEOUT_MS, ROTATED_REFRESH_CODES, RELOGIN, SLOT;
|
|
43626
44419
|
var init_chatgpt_refresh = __esm({
|
|
43627
44420
|
"../../packages/tacho/src/host/chatgpt-refresh.ts"() {
|
|
43628
44421
|
"use strict";
|
|
44422
|
+
init_model_failure();
|
|
43629
44423
|
init_model_credential();
|
|
43630
44424
|
CODEX_OAUTH_CLIENT_ID = "app_EMoamEEZ73f0CkXaXp7hrann";
|
|
43631
44425
|
CHATGPT_TOKEN_URL = "https://auth.openai.com/oauth/token";
|
|
43632
44426
|
CHATGPT_REFRESH_MARGIN_MS = 60 * 6e4;
|
|
43633
44427
|
CHATGPT_REFRESH_MAX_AGE_MS = 7 * 24 * 60 * 6e4;
|
|
44428
|
+
CHATGPT_REFRESH_TIMEOUT_MS = 1e4;
|
|
44429
|
+
ROTATED_REFRESH_CODES = /* @__PURE__ */ new Set([
|
|
44430
|
+
"refresh_token_reused",
|
|
44431
|
+
"refresh_token_invalidated"
|
|
44432
|
+
]);
|
|
44433
|
+
RELOGIN = "run `codex login`, then `oxagen agent enroll`";
|
|
44434
|
+
SLOT = ["openai", "codex"];
|
|
44435
|
+
}
|
|
44436
|
+
});
|
|
44437
|
+
|
|
44438
|
+
// ../../packages/tacho/src/host/credential-pool.ts
|
|
44439
|
+
function chatGptTokensFromVault(saved) {
|
|
44440
|
+
let parsed2;
|
|
44441
|
+
try {
|
|
44442
|
+
parsed2 = JSON.parse(saved);
|
|
44443
|
+
} catch {
|
|
44444
|
+
return void 0;
|
|
44445
|
+
}
|
|
44446
|
+
if (parsed2 === null || typeof parsed2 !== "object") return void 0;
|
|
44447
|
+
const outer = parsed2;
|
|
44448
|
+
const inner = outer["tokens"];
|
|
44449
|
+
const tokens = inner !== null && typeof inner === "object" ? inner : outer;
|
|
44450
|
+
const text6 = (key) => {
|
|
44451
|
+
const value = tokens[key];
|
|
44452
|
+
return typeof value === "string" && value.length > 0 ? value : void 0;
|
|
44453
|
+
};
|
|
44454
|
+
const access2 = text6("access_token");
|
|
44455
|
+
if (access2 === void 0) return void 0;
|
|
44456
|
+
const idToken = text6("id_token");
|
|
44457
|
+
const accountId = text6("account_id") ?? accountOfIdToken(idToken);
|
|
44458
|
+
return JSON.stringify({
|
|
44459
|
+
access_token: access2,
|
|
44460
|
+
refresh_token: text6("refresh_token") ?? "",
|
|
44461
|
+
...idToken !== void 0 ? { id_token: idToken } : {},
|
|
44462
|
+
...accountId !== void 0 ? { account_id: accountId } : {}
|
|
44463
|
+
});
|
|
44464
|
+
}
|
|
44465
|
+
function accountOfIdToken(idToken) {
|
|
44466
|
+
const payload = idToken?.split(".")[1];
|
|
44467
|
+
if (payload === void 0 || payload.length === 0) return void 0;
|
|
44468
|
+
let claims;
|
|
44469
|
+
try {
|
|
44470
|
+
claims = JSON.parse(Buffer.from(payload, "base64url").toString("utf8"));
|
|
44471
|
+
} catch {
|
|
44472
|
+
return void 0;
|
|
44473
|
+
}
|
|
44474
|
+
if (claims === null || typeof claims !== "object") return void 0;
|
|
44475
|
+
const auth2 = claims["https://api.openai.com/auth"];
|
|
44476
|
+
if (auth2 === null || typeof auth2 !== "object") return void 0;
|
|
44477
|
+
const account = auth2["chatgpt_account_id"];
|
|
44478
|
+
return typeof account === "string" && account.length > 0 ? account : void 0;
|
|
44479
|
+
}
|
|
44480
|
+
function poolMemberOf(credential, provider, harness) {
|
|
44481
|
+
if (credential.provider !== provider)
|
|
44482
|
+
return { skipped: `it is a ${credential.provider} credential` };
|
|
44483
|
+
if (credential.status !== "active")
|
|
44484
|
+
return { skipped: `it is ${credential.status}` };
|
|
44485
|
+
let kind;
|
|
44486
|
+
let secret = credential.secret.trim();
|
|
44487
|
+
if (credential.authType === "api_key" && credential.harness === null) {
|
|
44488
|
+
kind = provider === "anthropic" ? anthropicCredentialKind(secret, "api_key") : "bearer";
|
|
44489
|
+
} else if (credential.authType === "subscription_token" && credential.harness === harness && harness === "claude-code" && provider === "anthropic") {
|
|
44490
|
+
kind = "oauth";
|
|
44491
|
+
} else if (credential.authType === "subscription_token" && credential.harness === harness && harness === "codex" && provider === "openai") {
|
|
44492
|
+
const tokens = chatGptTokensFromVault(secret);
|
|
44493
|
+
if (tokens === void 0)
|
|
44494
|
+
return { skipped: "its ChatGPT login holds no access token" };
|
|
44495
|
+
kind = "chatgpt";
|
|
44496
|
+
secret = tokens;
|
|
44497
|
+
} else {
|
|
44498
|
+
return { skipped: `a ${credential.authType} does not serve ${harness}` };
|
|
44499
|
+
}
|
|
44500
|
+
const limitedUntil = credential.limitedUntil === null ? Number.NaN : Date.parse(credential.limitedUntil);
|
|
44501
|
+
return {
|
|
44502
|
+
credential_id: credential.id,
|
|
44503
|
+
kind,
|
|
44504
|
+
secret,
|
|
44505
|
+
hint: credential.hint,
|
|
44506
|
+
...credential.label !== null ? { label: credential.label } : {},
|
|
44507
|
+
...Number.isFinite(limitedUntil) ? { limited_until: limitedUntil } : {},
|
|
44508
|
+
changed_at: credential.rotatedAt ?? credential.createdAt
|
|
44509
|
+
};
|
|
44510
|
+
}
|
|
44511
|
+
function slotTakesPool(store, provider, harness) {
|
|
44512
|
+
const own = store.pool(provider, harness).find((member4) => member4.source !== VAULT_POOL_SOURCE);
|
|
44513
|
+
return own !== void 0 && own.source !== "sandbox:launch";
|
|
44514
|
+
}
|
|
44515
|
+
async function syncCredentialPools(deps) {
|
|
44516
|
+
const reports = [];
|
|
44517
|
+
const harnesses = [...new Set(deps.harnesses)].filter(isBrokerableHarness);
|
|
44518
|
+
for (const harness of harnesses) {
|
|
44519
|
+
const provider = BROKERABLE_HARNESS_PROVIDER[harness];
|
|
44520
|
+
let takes;
|
|
44521
|
+
try {
|
|
44522
|
+
takes = slotTakesPool(deps.store, provider, harness);
|
|
44523
|
+
} catch (error2) {
|
|
44524
|
+
const detail = error2 instanceof Error ? error2.message : String(error2);
|
|
44525
|
+
deps.log(
|
|
44526
|
+
`credential pool sync: custody for ${harness} is unreadable, so it was not synced: ${detail}`
|
|
44527
|
+
);
|
|
44528
|
+
reports.push({ harness, synced: false, reason: "fetch_failed", detail });
|
|
44529
|
+
continue;
|
|
44530
|
+
}
|
|
44531
|
+
if (!takes) {
|
|
44532
|
+
reports.push({ harness, synced: false, reason: "not_brokered" });
|
|
44533
|
+
continue;
|
|
44534
|
+
}
|
|
44535
|
+
let credentials2;
|
|
44536
|
+
try {
|
|
44537
|
+
credentials2 = (await deps.client.modelCredentials(harness)).credentials;
|
|
44538
|
+
} catch (error2) {
|
|
44539
|
+
const detail = error2 instanceof ControlError ? controlErrorMessage(error2) : error2 instanceof Error ? error2.message : String(error2);
|
|
44540
|
+
deps.log(
|
|
44541
|
+
`credential pool sync: could not read the credentials saved for ${harness}, so custody keeps what it holds: ${detail}`
|
|
44542
|
+
);
|
|
44543
|
+
reports.push({ harness, synced: false, reason: "fetch_failed", detail });
|
|
44544
|
+
continue;
|
|
44545
|
+
}
|
|
44546
|
+
const members2 = [];
|
|
44547
|
+
for (const credential of credentials2) {
|
|
44548
|
+
const member4 = poolMemberOf(credential, provider, harness);
|
|
44549
|
+
if ("skipped" in member4) {
|
|
44550
|
+
deps.log(
|
|
44551
|
+
`credential pool sync: ${credential.id} does not join ${harness}'s pool: ${member4.skipped}`
|
|
44552
|
+
);
|
|
44553
|
+
continue;
|
|
44554
|
+
}
|
|
44555
|
+
members2.push(member4);
|
|
44556
|
+
}
|
|
44557
|
+
try {
|
|
44558
|
+
const outcome = deps.store.syncPool(
|
|
44559
|
+
provider,
|
|
44560
|
+
harness,
|
|
44561
|
+
members2,
|
|
44562
|
+
deps.now()
|
|
44563
|
+
);
|
|
44564
|
+
if (outcome.synced)
|
|
44565
|
+
deps.log(
|
|
44566
|
+
`credential pool sync: ${harness} holds ${outcome.added + outcome.kept} saved credentials after its own (${outcome.added} added, ${outcome.removed} removed)`
|
|
44567
|
+
);
|
|
44568
|
+
reports.push({ harness, ...outcome });
|
|
44569
|
+
} catch (error2) {
|
|
44570
|
+
const detail = error2 instanceof Error ? error2.message : String(error2);
|
|
44571
|
+
deps.log(
|
|
44572
|
+
`credential pool sync: custody for ${harness} could not be written, so it keeps what it held: ${detail}`
|
|
44573
|
+
);
|
|
44574
|
+
reports.push({ harness, synced: false, reason: "fetch_failed", detail });
|
|
44575
|
+
}
|
|
44576
|
+
}
|
|
44577
|
+
return reports;
|
|
44578
|
+
}
|
|
44579
|
+
function createCredentialStateReporter(deps) {
|
|
44580
|
+
const sent = /* @__PURE__ */ new Map();
|
|
44581
|
+
return (credentialId, report) => {
|
|
44582
|
+
const key = report.state === "invalid" ? `invalid:${report.reason}` : report.state;
|
|
44583
|
+
const at2 = deps.now();
|
|
44584
|
+
const last = sent.get(credentialId);
|
|
44585
|
+
if (last !== void 0 && last.key === key && at2 - last.at < CREDENTIAL_REPORT_REPEAT_MS)
|
|
44586
|
+
return;
|
|
44587
|
+
sent.set(credentialId, { key, at: at2 });
|
|
44588
|
+
void deps.client.reportModelCredential(credentialId, report).catch((error2) => {
|
|
44589
|
+
sent.delete(credentialId);
|
|
44590
|
+
deps.log(
|
|
44591
|
+
`credential pool: could not tell Oxagen that ${credentialId} is ${report.state}: ${error2 instanceof ControlError ? controlErrorMessage(error2) : error2 instanceof Error ? error2.message : String(error2)}`
|
|
44592
|
+
);
|
|
44593
|
+
});
|
|
44594
|
+
};
|
|
44595
|
+
}
|
|
44596
|
+
var CREDENTIAL_POOL_SYNC_MS, CREDENTIAL_REPORT_REPEAT_MS;
|
|
44597
|
+
var init_credential_pool = __esm({
|
|
44598
|
+
"../../packages/tacho/src/host/credential-pool.ts"() {
|
|
44599
|
+
"use strict";
|
|
44600
|
+
init_credential_store();
|
|
44601
|
+
init_control_client();
|
|
44602
|
+
init_wire();
|
|
44603
|
+
CREDENTIAL_POOL_SYNC_MS = 15 * 6e4;
|
|
44604
|
+
CREDENTIAL_REPORT_REPEAT_MS = 6e4;
|
|
43634
44605
|
}
|
|
43635
44606
|
});
|
|
43636
44607
|
|
|
@@ -50763,8 +51734,8 @@ function createGithubProxy(deps) {
|
|
|
50763
51734
|
const path2 = requestPath(url2.pathname, lease);
|
|
50764
51735
|
const service = url2.searchParams.get("service");
|
|
50765
51736
|
const discovery = path2?.service === "info/refs" && req.method === "GET" && url2.searchParams.size === 1 && ["git-receive-pack", "git-upload-pack"].includes(service ?? "");
|
|
50766
|
-
const
|
|
50767
|
-
if (!path2 || !discovery && !
|
|
51737
|
+
const exchange2 = path2 !== void 0 && path2.service !== "info/refs" && req.method === "POST" && url2.search === "" && req.headers["content-type"] === `application/x-${path2.service}-request`;
|
|
51738
|
+
if (!path2 || !discovery && !exchange2) {
|
|
50768
51739
|
reply(
|
|
50769
51740
|
res,
|
|
50770
51741
|
403,
|
|
@@ -50891,7 +51862,7 @@ function createGithubProxy(deps) {
|
|
|
50891
51862
|
headers,
|
|
50892
51863
|
redirect: "manual",
|
|
50893
51864
|
signal: controller.signal,
|
|
50894
|
-
...
|
|
51865
|
+
...exchange2 ? {
|
|
50895
51866
|
body: Readable.toWeb(
|
|
50896
51867
|
Readable.from(body2())
|
|
50897
51868
|
),
|
|
@@ -51304,9 +52275,9 @@ var init_memory_send = __esm({
|
|
|
51304
52275
|
"../../packages/tacho/src/collector/memory-capture/memory-send.ts"() {
|
|
51305
52276
|
"use strict";
|
|
51306
52277
|
MemoryRateLimited = class extends Error {
|
|
51307
|
-
constructor(
|
|
52278
|
+
constructor(retryAfterMs3) {
|
|
51308
52279
|
super("memory upload: the control plane answered 429");
|
|
51309
|
-
this.retryAfterMs =
|
|
52280
|
+
this.retryAfterMs = retryAfterMs3;
|
|
51310
52281
|
this.name = "MemoryRateLimited";
|
|
51311
52282
|
}
|
|
51312
52283
|
retryAfterMs;
|
|
@@ -52059,7 +53030,7 @@ async function postToControlPlane(fetch2, host, path2, body2, signal) {
|
|
|
52059
53030
|
body: payload,
|
|
52060
53031
|
signal
|
|
52061
53032
|
});
|
|
52062
|
-
const
|
|
53033
|
+
const retryAfterMs3 = parseRetryAfter(
|
|
52063
53034
|
response.headers?.get("retry-after") ?? null,
|
|
52064
53035
|
Date.now()
|
|
52065
53036
|
);
|
|
@@ -52067,7 +53038,7 @@ async function postToControlPlane(fetch2, host, path2, body2, signal) {
|
|
|
52067
53038
|
ok: response.ok,
|
|
52068
53039
|
status: response.status,
|
|
52069
53040
|
text: await response.text(),
|
|
52070
|
-
...
|
|
53041
|
+
...retryAfterMs3 !== void 0 ? { retryAfterMs: retryAfterMs3 } : {}
|
|
52071
53042
|
};
|
|
52072
53043
|
}
|
|
52073
53044
|
function changedFailureLog(write) {
|
|
@@ -56272,7 +57243,7 @@ function serverEnvironment(env, settings) {
|
|
|
56272
57243
|
function createCodeGraphSupervisor(deps) {
|
|
56273
57244
|
const home = deps.home ?? homedir6();
|
|
56274
57245
|
const root = codegraphRoot(deps.env, home);
|
|
56275
|
-
const
|
|
57246
|
+
const spawn10 = deps.spawn ?? spawnChild;
|
|
56276
57247
|
const sleep2 = deps.sleep ?? ((ms) => new Promise((resolve29) => setTimeout(resolve29, ms)));
|
|
56277
57248
|
const localFetch = deps.localFetch ?? ((url2, init) => globalThis.fetch(url2, init));
|
|
56278
57249
|
const isExecutable2 = deps.isExecutable ?? defaultIsExecutable;
|
|
@@ -56325,7 +57296,7 @@ function createCodeGraphSupervisor(deps) {
|
|
|
56325
57296
|
}
|
|
56326
57297
|
function runOnce(bin, args) {
|
|
56327
57298
|
return new Promise((resolve29) => {
|
|
56328
|
-
const child =
|
|
57299
|
+
const child = spawn10(bin, args, {
|
|
56329
57300
|
env: serverEnvironment(deps.env, void 0),
|
|
56330
57301
|
stdio: ["ignore", "ignore", "pipe"]
|
|
56331
57302
|
});
|
|
@@ -56486,7 +57457,7 @@ function createCodeGraphSupervisor(deps) {
|
|
|
56486
57457
|
);
|
|
56487
57458
|
facts.memoryMb = memory.mb;
|
|
56488
57459
|
facts.memoryFrom = memory.from;
|
|
56489
|
-
const child =
|
|
57460
|
+
const child = spawn10(
|
|
56490
57461
|
bin,
|
|
56491
57462
|
[
|
|
56492
57463
|
"serve",
|
|
@@ -58096,13 +59067,13 @@ function providerError(provider, status2, code, message2) {
|
|
|
58096
59067
|
const body2 = provider === "anthropic" ? {
|
|
58097
59068
|
type: "error",
|
|
58098
59069
|
error: {
|
|
58099
|
-
type: status2 === 401 ? "authentication_error" : status2 === 403 ? "permission_error" : "api_error",
|
|
59070
|
+
type: status2 === 401 ? "authentication_error" : status2 === 403 ? "permission_error" : status2 === 429 ? "rate_limit_error" : "api_error",
|
|
58100
59071
|
message: `${message2} (${code})`
|
|
58101
59072
|
}
|
|
58102
59073
|
} : {
|
|
58103
59074
|
error: {
|
|
58104
59075
|
message: message2,
|
|
58105
|
-
type: status2 === 401 || status2 === 403 ? "invalid_request_error" : "server_error",
|
|
59076
|
+
type: status2 === 401 || status2 === 403 ? "invalid_request_error" : status2 === 429 ? "rate_limit_exceeded" : "server_error",
|
|
58106
59077
|
param: null,
|
|
58107
59078
|
code: status2 === 401 ? "invalid_api_key" : code
|
|
58108
59079
|
}
|
|
@@ -58466,6 +59437,7 @@ import {
|
|
|
58466
59437
|
Agent as HttpAgent
|
|
58467
59438
|
} from "node:http";
|
|
58468
59439
|
import { Agent as HttpsAgent, request as httpsRequest } from "node:https";
|
|
59440
|
+
import { PassThrough } from "node:stream";
|
|
58469
59441
|
async function landedWithin(landing, ms) {
|
|
58470
59442
|
let timer;
|
|
58471
59443
|
try {
|
|
@@ -58647,6 +59619,95 @@ function presentedCredential(req) {
|
|
|
58647
59619
|
function credentialRefusalStatus(code) {
|
|
58648
59620
|
return code === "run_token_expired" || code === "run_token_invalid" || code === "run_token_malformed" ? 401 : 403;
|
|
58649
59621
|
}
|
|
59622
|
+
function memberName(member4) {
|
|
59623
|
+
const tail = member4.hint !== void 0 && member4.hint.length > 0 ? `\u2026${member4.hint}` : "a credential";
|
|
59624
|
+
return `${tail} (${isLoginKind(member4.kind) ? "login" : "key"})`;
|
|
59625
|
+
}
|
|
59626
|
+
function holdOf(failure4, now) {
|
|
59627
|
+
return {
|
|
59628
|
+
kind: failure4.kind,
|
|
59629
|
+
until: isUsageLimit(failure4) ? failure4.until.getTime() : now + DEAD_CREDENTIAL_HOLD_MS
|
|
59630
|
+
};
|
|
59631
|
+
}
|
|
59632
|
+
function exhaustedRefusal(provider, members2, now) {
|
|
59633
|
+
const vendor = provider === "anthropic" ? "Anthropic" : "OpenAI";
|
|
59634
|
+
const lines = members2.map(({ member: member4, kind, until }) => {
|
|
59635
|
+
const words3 = FAILURE_WORDS[kind];
|
|
59636
|
+
return kind === "invalid_token" || kind === "account_deactivated" ? `${memberName(member4)} ${words3}` : `${memberName(member4)} ${words3} until ${new Date(until).toISOString()}`;
|
|
59637
|
+
});
|
|
59638
|
+
const resets = members2.filter(
|
|
59639
|
+
({ kind }) => kind === "rate_limit" || kind === "usage_limit" || kind === "credit_exhausted"
|
|
59640
|
+
).map(({ until }) => until);
|
|
59641
|
+
const soonest = resets.length === 0 ? void 0 : Math.min(...resets);
|
|
59642
|
+
const message2 = `Every ${vendor} credential this machine holds failed: ${lines.join("; ")}. ${soonest === void 0 ? "Save another credential in Oxagen." : "Save another credential in Oxagen, or wait for a limit to reset."}`;
|
|
59643
|
+
if (soonest !== void 0 && soonest - now <= EXHAUSTED_RETRY_MAX_MS)
|
|
59644
|
+
return {
|
|
59645
|
+
status: 429,
|
|
59646
|
+
message: message2,
|
|
59647
|
+
retryAfterSeconds: Math.max(1, Math.ceil((soonest - now) / 1e3))
|
|
59648
|
+
};
|
|
59649
|
+
return { status: 403, message: message2 };
|
|
59650
|
+
}
|
|
59651
|
+
function attachOf(held) {
|
|
59652
|
+
if (held.kind !== "chatgpt") return { kind: held.kind, secret: held.secret };
|
|
59653
|
+
const login = decodeChatGptLogin(held.secret);
|
|
59654
|
+
if (login === void 0) return void 0;
|
|
59655
|
+
return {
|
|
59656
|
+
kind: "chatgpt",
|
|
59657
|
+
secret: login.access_token,
|
|
59658
|
+
...login.account_id !== void 0 ? { accountId: login.account_id } : {}
|
|
59659
|
+
};
|
|
59660
|
+
}
|
|
59661
|
+
function headerLookup(response) {
|
|
59662
|
+
return {
|
|
59663
|
+
get: (name2) => {
|
|
59664
|
+
const value = response.headers[name2.toLowerCase()];
|
|
59665
|
+
return typeof value === "string" ? value : Array.isArray(value) ? value.join(", ") : null;
|
|
59666
|
+
}
|
|
59667
|
+
};
|
|
59668
|
+
}
|
|
59669
|
+
function peekResponse(response, max2) {
|
|
59670
|
+
return new Promise((resolve29) => {
|
|
59671
|
+
const chunks = [];
|
|
59672
|
+
let size = 0;
|
|
59673
|
+
const done = (result2) => {
|
|
59674
|
+
response.off("data", onData);
|
|
59675
|
+
response.off("end", onEnd);
|
|
59676
|
+
response.off("error", onFail);
|
|
59677
|
+
response.off("aborted", onAborted);
|
|
59678
|
+
resolve29(result2);
|
|
59679
|
+
};
|
|
59680
|
+
const onData = (chunk) => {
|
|
59681
|
+
chunks.push(chunk);
|
|
59682
|
+
size += chunk.length;
|
|
59683
|
+
if (size > max2) {
|
|
59684
|
+
response.pause();
|
|
59685
|
+
done({ chunks, ended: false });
|
|
59686
|
+
}
|
|
59687
|
+
};
|
|
59688
|
+
const onEnd = () => done({ chunks, ended: true });
|
|
59689
|
+
const onFail = (error2) => done({ chunks, ended: false, failed: error2 });
|
|
59690
|
+
const onAborted = () => done({ chunks, ended: false, failed: new Error("aborted") });
|
|
59691
|
+
response.on("data", onData);
|
|
59692
|
+
response.once("end", onEnd);
|
|
59693
|
+
response.once("error", onFail);
|
|
59694
|
+
response.once("aborted", onAborted);
|
|
59695
|
+
});
|
|
59696
|
+
}
|
|
59697
|
+
function replayOf(response, peeked2) {
|
|
59698
|
+
const replay = new PassThrough();
|
|
59699
|
+
for (const chunk of peeked2.chunks) replay.write(chunk);
|
|
59700
|
+
if (peeked2.failed !== void 0) {
|
|
59701
|
+
replay.destroy(peeked2.failed);
|
|
59702
|
+
} else if (peeked2.ended) {
|
|
59703
|
+
replay.end();
|
|
59704
|
+
} else {
|
|
59705
|
+
response.on("error", (error2) => replay.destroy(error2));
|
|
59706
|
+
response.on("aborted", () => replay.destroy(new Error("aborted")));
|
|
59707
|
+
response.pipe(replay);
|
|
59708
|
+
}
|
|
59709
|
+
return replay;
|
|
59710
|
+
}
|
|
58650
59711
|
function createModelProxy(deps) {
|
|
58651
59712
|
const maxRequestBytes = deps.maxRequestBytes ?? DEFAULT_MAX_REQUEST_BYTES;
|
|
58652
59713
|
const upstreamIdleMs = deps.upstreamIdleMs ?? DEFAULT_UPSTREAM_IDLE_MS;
|
|
@@ -58926,44 +59987,54 @@ function createModelProxy(deps) {
|
|
|
58926
59987
|
}
|
|
58927
59988
|
};
|
|
58928
59989
|
}
|
|
58929
|
-
const
|
|
58930
|
-
|
|
58931
|
-
|
|
58932
|
-
|
|
58933
|
-
|
|
58934
|
-
|
|
58935
|
-
|
|
58936
|
-
|
|
58937
|
-
|
|
58938
|
-
|
|
58939
|
-
|
|
58940
|
-
|
|
58941
|
-
const
|
|
58942
|
-
|
|
58943
|
-
|
|
58944
|
-
|
|
58945
|
-
|
|
58946
|
-
|
|
58947
|
-
|
|
58948
|
-
|
|
58949
|
-
|
|
58950
|
-
|
|
58951
|
-
|
|
58952
|
-
|
|
58953
|
-
|
|
58954
|
-
|
|
58955
|
-
|
|
58956
|
-
|
|
58957
|
-
|
|
58958
|
-
|
|
58959
|
-
|
|
59990
|
+
const unavailable = {
|
|
59991
|
+
basis: TACHO_CREDENTIAL_GATEWAY_BROKERED,
|
|
59992
|
+
claims: verdict.claims,
|
|
59993
|
+
refusal: {
|
|
59994
|
+
code: "credential_unavailable",
|
|
59995
|
+
message: CREDENTIAL_MESSAGES.credential_unavailable
|
|
59996
|
+
}
|
|
59997
|
+
};
|
|
59998
|
+
const pool = broker.pool;
|
|
59999
|
+
if (pool !== void 0) {
|
|
60000
|
+
const fits = memberFits(route);
|
|
60001
|
+
const now = deps.now();
|
|
60002
|
+
const passed = /* @__PURE__ */ new Set();
|
|
60003
|
+
for (; ; ) {
|
|
60004
|
+
const member4 = pool.next(route.provider, owner, {
|
|
60005
|
+
now,
|
|
60006
|
+
fits,
|
|
60007
|
+
tried: passed,
|
|
60008
|
+
allowHeldBack: true
|
|
60009
|
+
});
|
|
60010
|
+
if (member4 === void 0) return unavailable;
|
|
60011
|
+
const held3 = pool.open(route.provider, owner, member4.id);
|
|
60012
|
+
const attach2 = held3 === void 0 ? void 0 : attachOf(held3);
|
|
60013
|
+
if (attach2 !== void 0)
|
|
60014
|
+
return {
|
|
60015
|
+
basis: TACHO_CREDENTIAL_GATEWAY_BROKERED,
|
|
60016
|
+
claims: verdict.claims,
|
|
60017
|
+
attach: attach2,
|
|
60018
|
+
member: member4,
|
|
60019
|
+
poolSize: pool.members(route.provider, owner).filter(fits).length
|
|
60020
|
+
};
|
|
60021
|
+
passed.add(member4.id);
|
|
60022
|
+
}
|
|
58960
60023
|
}
|
|
60024
|
+
const held2 = broker.custody(route.provider, owner);
|
|
60025
|
+
const attach = held2 === void 0 ? void 0 : attachOf(held2);
|
|
60026
|
+
if (attach === void 0) return unavailable;
|
|
58961
60027
|
return {
|
|
58962
60028
|
basis: TACHO_CREDENTIAL_GATEWAY_BROKERED,
|
|
58963
60029
|
claims: verdict.claims,
|
|
58964
|
-
attach
|
|
60030
|
+
attach
|
|
58965
60031
|
};
|
|
58966
60032
|
}
|
|
60033
|
+
function memberFits(route) {
|
|
60034
|
+
const chatgpt = route.upstream === "chatgpt";
|
|
60035
|
+
const copiesServe = deps.credentials?.pool?.copiesServe?.(route.upstream) ?? true;
|
|
60036
|
+
return (member4) => member4.kind === "chatgpt" === chatgpt && (copiesServe || member4.source !== VAULT_POOL_SOURCE);
|
|
60037
|
+
}
|
|
58967
60038
|
function attrsFor(route, how, credential) {
|
|
58968
60039
|
return {
|
|
58969
60040
|
[TACHO_ENFORCEMENT_TIER_ATTR]: TACHO_GATEWAY_TIER,
|
|
@@ -59057,7 +60128,7 @@ function createModelProxy(deps) {
|
|
|
59057
60128
|
lost(error2);
|
|
59058
60129
|
}
|
|
59059
60130
|
}
|
|
59060
|
-
function sendProviderError(res, route, status2, code, message2, retryable = false) {
|
|
60131
|
+
function sendProviderError(res, route, status2, code, message2, retryable = false, retryAfterSeconds) {
|
|
59061
60132
|
if (heldStreams.has(res)) {
|
|
59062
60133
|
if (!res.writableEnded)
|
|
59063
60134
|
res.end(heldStreamErrorEvent(status2, void 0, message2));
|
|
@@ -59077,7 +60148,7 @@ function createModelProxy(deps) {
|
|
|
59077
60148
|
// should a failure on the way to the vendor, a second later: without
|
|
59078
60149
|
// it a reset connection reached the person as a failed turn.
|
|
59079
60150
|
"x-should-retry": retryable ? "true" : "false",
|
|
59080
|
-
...retryable ? { "retry-after":
|
|
60151
|
+
...retryable ? { "retry-after": String(retryAfterSeconds ?? 1) } : {}
|
|
59081
60152
|
});
|
|
59082
60153
|
res.end(error2.body);
|
|
59083
60154
|
}
|
|
@@ -59856,15 +60927,24 @@ function createModelProxy(deps) {
|
|
|
59856
60927
|
const responseBody = new BodyCapture();
|
|
59857
60928
|
let meter;
|
|
59858
60929
|
let settledUsage;
|
|
59859
|
-
|
|
59860
|
-
|
|
59861
|
-
|
|
59862
|
-
|
|
59863
|
-
|
|
59864
|
-
|
|
59865
|
-
|
|
59866
|
-
|
|
59867
|
-
|
|
60930
|
+
let currentAttach = credential.attach;
|
|
60931
|
+
let currentMember = credential.member;
|
|
60932
|
+
const headersFor = (attach) => {
|
|
60933
|
+
const built = upstreamRequestHeaders(
|
|
60934
|
+
req.rawHeaders,
|
|
60935
|
+
target.host,
|
|
60936
|
+
body2.length,
|
|
60937
|
+
dropContentEncoding,
|
|
60938
|
+
attach
|
|
60939
|
+
);
|
|
60940
|
+
if (deps.cloudGateway && record2 !== void 0)
|
|
60941
|
+
built.push(MODEL_STEERING_RUN_HEADER, record2.recorder.sessionUuid);
|
|
60942
|
+
return built;
|
|
60943
|
+
};
|
|
60944
|
+
let headers = headersFor(currentAttach);
|
|
60945
|
+
let loginRefreshed = false;
|
|
60946
|
+
const tried = /* @__PURE__ */ new Set();
|
|
60947
|
+
const rotation = [];
|
|
59868
60948
|
const settle4 = (errorClass2) => {
|
|
59869
60949
|
if (settled2) return;
|
|
59870
60950
|
settled2 = true;
|
|
@@ -59923,7 +61003,7 @@ function createModelProxy(deps) {
|
|
|
59923
61003
|
target.host,
|
|
59924
61004
|
keepAliveCandidate.body.length,
|
|
59925
61005
|
true,
|
|
59926
|
-
|
|
61006
|
+
currentAttach
|
|
59927
61007
|
),
|
|
59928
61008
|
...deps.cloudGateway ? [MODEL_STEERING_RUN_HEADER, record2.recorder.sessionUuid] : []
|
|
59929
61009
|
],
|
|
@@ -59996,7 +61076,7 @@ function createModelProxy(deps) {
|
|
|
59996
61076
|
priced,
|
|
59997
61077
|
familyPriced,
|
|
59998
61078
|
settledAt,
|
|
59999
|
-
durationMs,
|
|
61079
|
+
durationMs: durationMs2,
|
|
60000
61080
|
failed: failed5
|
|
60001
61081
|
}) => {
|
|
60002
61082
|
const responseText = responseBody.text();
|
|
@@ -60023,7 +61103,7 @@ function createModelProxy(deps) {
|
|
|
60023
61103
|
estimated: cut || unreported || familyPriced,
|
|
60024
61104
|
requestEffort,
|
|
60025
61105
|
ttftMs: firstByteAt !== void 0 ? Math.max(0, firstByteAt - startedAt) : void 0,
|
|
60026
|
-
durationMs,
|
|
61106
|
+
durationMs: durationMs2,
|
|
60027
61107
|
status: status2,
|
|
60028
61108
|
failed: failed5,
|
|
60029
61109
|
requestId
|
|
@@ -60103,9 +61183,17 @@ function createModelProxy(deps) {
|
|
|
60103
61183
|
upstreamReq?.destroy(new Error("client closed the connection"));
|
|
60104
61184
|
settle4(abortReason !== void 0 ? "interrupted" : "client_aborted");
|
|
60105
61185
|
});
|
|
60106
|
-
const
|
|
61186
|
+
const deliver = (upstream, stream) => {
|
|
60107
61187
|
status2 = upstream.statusCode ?? 502;
|
|
60108
61188
|
firstByteAt = deps.now();
|
|
61189
|
+
if (rotation.length > 0)
|
|
61190
|
+
attrs2[CREDENTIAL_ROTATION_ATTR] = rotationAttr(currentMember);
|
|
61191
|
+
if (metered && status2 < 400 && currentMember?.failure !== void 0 && deps.credentials?.pool !== void 0)
|
|
61192
|
+
deps.credentials.pool.served(
|
|
61193
|
+
route.provider,
|
|
61194
|
+
custodyHarnessFor(route),
|
|
61195
|
+
currentMember
|
|
61196
|
+
);
|
|
60109
61197
|
const idHeader = upstream.headers["request-id"] ?? upstream.headers["x-request-id"];
|
|
60110
61198
|
requestId = typeof idHeader === "string" ? idHeader.slice(0, 512) : void 0;
|
|
60111
61199
|
const contentType2 = upstream.headers["content-type"];
|
|
@@ -60141,7 +61229,7 @@ function createModelProxy(deps) {
|
|
|
60141
61229
|
res.flushHeaders();
|
|
60142
61230
|
res.socket?.setNoDelay(true);
|
|
60143
61231
|
}
|
|
60144
|
-
|
|
61232
|
+
stream.on("data", (chunk) => {
|
|
60145
61233
|
if (settled2) return;
|
|
60146
61234
|
if (heldError !== void 0 && heldErrorBytes < HELD_STREAM_ERROR_BYTES) {
|
|
60147
61235
|
heldError.push(chunk);
|
|
@@ -60156,7 +61244,7 @@ function createModelProxy(deps) {
|
|
|
60156
61244
|
}
|
|
60157
61245
|
});
|
|
60158
61246
|
const settleDeferred = (errorClass2) => process.nextTick(() => settle4(errorClass2));
|
|
60159
|
-
|
|
61247
|
+
stream.on("end", () => {
|
|
60160
61248
|
if (heldError !== void 0 && !res.writableEnded)
|
|
60161
61249
|
res.end(
|
|
60162
61250
|
heldStreamErrorEvent(
|
|
@@ -60187,11 +61275,174 @@ function createModelProxy(deps) {
|
|
|
60187
61275
|
settle4(abortReason !== void 0 ? "interrupted" : "upstream_reset");
|
|
60188
61276
|
res.destroy();
|
|
60189
61277
|
};
|
|
60190
|
-
|
|
60191
|
-
|
|
61278
|
+
stream.on("error", failResponse);
|
|
61279
|
+
stream.on("aborted", () => {
|
|
60192
61280
|
failResponse();
|
|
60193
61281
|
});
|
|
60194
|
-
if (heldError === void 0)
|
|
61282
|
+
if (heldError === void 0) stream.pipe(res);
|
|
61283
|
+
};
|
|
61284
|
+
const rotationAttr = (last) => [
|
|
61285
|
+
...rotation.map(({ member: member4, kind }) => `${member4.id}:${kind}`),
|
|
61286
|
+
...last !== void 0 && !rotation.some((r) => r.member === last) ? [`${last.id}:answered`] : []
|
|
61287
|
+
].join(",");
|
|
61288
|
+
const refreshesLogin = (answered) => answered === 401 && !loginRefreshed && currentMember?.kind === "chatgpt" && currentMember.refresh_refused === void 0 && deps.credentials?.pool?.refreshLogin !== void 0;
|
|
61289
|
+
const checksCredential = (answered) => deps.credentials?.pool !== void 0 && currentMember !== void 0 && ((credential.poolSize ?? 0) >= 2 && mayBeModelFailure(route.provider, answered) || refreshesLogin(answered));
|
|
61290
|
+
const onResponse = (upstream) => {
|
|
61291
|
+
const answered = upstream.statusCode ?? 502;
|
|
61292
|
+
if (!checksCredential(answered)) {
|
|
61293
|
+
deliver(upstream, upstream);
|
|
61294
|
+
return;
|
|
61295
|
+
}
|
|
61296
|
+
void checkCredential(upstream, answered).catch((error2) => {
|
|
61297
|
+
deps.log(
|
|
61298
|
+
`model proxy: the credential check of ${target.host}'s answer failed: ${error2 instanceof Error ? error2.message : String(error2)} session=${sessionKey}`
|
|
61299
|
+
);
|
|
61300
|
+
if (settled2) return;
|
|
61301
|
+
upstream.destroy();
|
|
61302
|
+
settle4("gateway_error");
|
|
61303
|
+
sendProviderError(
|
|
61304
|
+
res,
|
|
61305
|
+
route,
|
|
61306
|
+
502,
|
|
61307
|
+
"gateway_error",
|
|
61308
|
+
`The Oxagen gateway could not read the answer from ${target.host}. Retry the call.`,
|
|
61309
|
+
true
|
|
61310
|
+
);
|
|
61311
|
+
});
|
|
61312
|
+
};
|
|
61313
|
+
const checkCredential = async (upstream, answered) => {
|
|
61314
|
+
const peeked2 = await peekResponse(upstream, MODEL_FAILURE_BODY_MAX_BYTES);
|
|
61315
|
+
if (settled2 || abortReason !== void 0) {
|
|
61316
|
+
upstream.destroy();
|
|
61317
|
+
if (!settled2) settle4("interrupted");
|
|
61318
|
+
return;
|
|
61319
|
+
}
|
|
61320
|
+
if (peeked2.failed !== void 0 || !peeked2.ended) {
|
|
61321
|
+
deliver(upstream, replayOf(upstream, peeked2));
|
|
61322
|
+
return;
|
|
61323
|
+
}
|
|
61324
|
+
const encoding = upstream.headers["content-encoding"];
|
|
61325
|
+
const text6 = (await readableModelBody(
|
|
61326
|
+
Buffer.concat(peeked2.chunks),
|
|
61327
|
+
typeof encoding === "string" ? encoding : void 0,
|
|
61328
|
+
MODEL_FAILURE_BODY_MAX_BYTES
|
|
61329
|
+
))?.toString("utf8");
|
|
61330
|
+
if (settled2 || abortReason !== void 0) {
|
|
61331
|
+
if (!settled2) settle4("interrupted");
|
|
61332
|
+
return;
|
|
61333
|
+
}
|
|
61334
|
+
const now = deps.now();
|
|
61335
|
+
const failure4 = classifyModelFailure(
|
|
61336
|
+
route.provider,
|
|
61337
|
+
answered,
|
|
61338
|
+
headerLookup(upstream),
|
|
61339
|
+
text6 ?? null,
|
|
61340
|
+
new Date(now)
|
|
61341
|
+
);
|
|
61342
|
+
const pool = deps.credentials?.pool;
|
|
61343
|
+
const failed5 = currentMember;
|
|
61344
|
+
const owner = custodyHarnessFor(route);
|
|
61345
|
+
let refreshFailed;
|
|
61346
|
+
if (failure4?.kind === "invalid_token" && refreshesLogin(answered) && pool?.refreshLogin !== void 0 && failed5 !== void 0) {
|
|
61347
|
+
loginRefreshed = true;
|
|
61348
|
+
const refreshed = await pool.refreshLogin(
|
|
61349
|
+
route.provider,
|
|
61350
|
+
owner,
|
|
61351
|
+
failed5
|
|
61352
|
+
);
|
|
61353
|
+
if (settled2 || abortReason !== void 0) {
|
|
61354
|
+
if (!settled2) settle4("interrupted");
|
|
61355
|
+
return;
|
|
61356
|
+
}
|
|
61357
|
+
const held2 = refreshed.outcome === "refreshed" ? pool.open(route.provider, owner, failed5.id) : void 0;
|
|
61358
|
+
const attach = held2 === void 0 ? void 0 : attachOf(held2);
|
|
61359
|
+
if (attach !== void 0) {
|
|
61360
|
+
deps.log(
|
|
61361
|
+
`model proxy: refreshed the ChatGPT login ${memberName(failed5)} after a 401; sending the call again on it session=${sessionKey}`
|
|
61362
|
+
);
|
|
61363
|
+
currentAttach = attach;
|
|
61364
|
+
headers = headersFor(attach);
|
|
61365
|
+
upstreamReq = openUpstream(false);
|
|
61366
|
+
return;
|
|
61367
|
+
}
|
|
61368
|
+
refreshFailed = refreshed.outcome === "refreshed" ? "failed" : refreshed.outcome;
|
|
61369
|
+
deps.log(
|
|
61370
|
+
`model proxy: could not refresh the ChatGPT login ${memberName(failed5)} after a 401: ${refreshed.outcome === "refreshed" ? "custody did not open the new tokens" : refreshed.detail} session=${sessionKey}`
|
|
61371
|
+
);
|
|
61372
|
+
}
|
|
61373
|
+
if (failure4 === null || pool === void 0 || failed5 === void 0 || (credential.poolSize ?? 0) < 2) {
|
|
61374
|
+
deliver(upstream, replayOf(upstream, peeked2));
|
|
61375
|
+
return;
|
|
61376
|
+
}
|
|
61377
|
+
const hold = {
|
|
61378
|
+
...holdOf(failure4, now),
|
|
61379
|
+
...refreshFailed !== void 0 ? { refresh: refreshFailed } : {}
|
|
61380
|
+
};
|
|
61381
|
+
tried.add(failed5.id);
|
|
61382
|
+
rotation.push({ member: failed5, kind: failure4.kind, until: hold.until });
|
|
61383
|
+
pool.markFailed(route.provider, owner, failed5, hold, now);
|
|
61384
|
+
const loginsOnly = failure4.kind === "rate_limit" && isLoginKind(failed5.kind);
|
|
61385
|
+
const fits = memberFits(route);
|
|
61386
|
+
for (; ; ) {
|
|
61387
|
+
const next = pool.next(route.provider, owner, {
|
|
61388
|
+
now,
|
|
61389
|
+
fits,
|
|
61390
|
+
tried,
|
|
61391
|
+
loginsOnly,
|
|
61392
|
+
allowHeldBack: false
|
|
61393
|
+
});
|
|
61394
|
+
if (next === void 0) break;
|
|
61395
|
+
const held2 = pool.open(route.provider, owner, next.id);
|
|
61396
|
+
const attach = held2 === void 0 ? void 0 : attachOf(held2);
|
|
61397
|
+
if (attach === void 0) {
|
|
61398
|
+
tried.add(next.id);
|
|
61399
|
+
continue;
|
|
61400
|
+
}
|
|
61401
|
+
deps.log(
|
|
61402
|
+
`model proxy: ${route.provider} credential ${memberName(failed5)} ${FAILURE_WORDS[failure4.kind]}; sending the call again on ${memberName(next)} session=${sessionKey}`
|
|
61403
|
+
);
|
|
61404
|
+
currentMember = next;
|
|
61405
|
+
currentAttach = attach;
|
|
61406
|
+
headers = headersFor(attach);
|
|
61407
|
+
upstreamReq = openUpstream(false);
|
|
61408
|
+
return;
|
|
61409
|
+
}
|
|
61410
|
+
const members2 = pool.members(route.provider, owner).filter(fits);
|
|
61411
|
+
if (loginsOnly && members2.some(
|
|
61412
|
+
(member4) => !tried.has(member4.id) && !isLoginKind(member4.kind)
|
|
61413
|
+
)) {
|
|
61414
|
+
deliver(upstream, replayOf(upstream, peeked2));
|
|
61415
|
+
return;
|
|
61416
|
+
}
|
|
61417
|
+
const failures = members2.flatMap((member4) => {
|
|
61418
|
+
const here = rotation.find((r) => r.member.id === member4.id);
|
|
61419
|
+
if (here !== void 0)
|
|
61420
|
+
return [{ member: member4, kind: here.kind, until: here.until }];
|
|
61421
|
+
if (tried.has(member4.id) || member4.failure === void 0) return [];
|
|
61422
|
+
return [
|
|
61423
|
+
{
|
|
61424
|
+
member: member4,
|
|
61425
|
+
kind: member4.failure.kind,
|
|
61426
|
+
until: Date.parse(member4.failure.until)
|
|
61427
|
+
}
|
|
61428
|
+
];
|
|
61429
|
+
});
|
|
61430
|
+
const refusal = exhaustedRefusal(route.provider, failures, now);
|
|
61431
|
+
status2 = refusal.status;
|
|
61432
|
+
attrs2[CREDENTIAL_ROTATION_ATTR] = rotationAttr(void 0);
|
|
61433
|
+
deps.log(
|
|
61434
|
+
`model proxy: every ${route.provider} credential failed (${rotationAttr(void 0)}) session=${sessionKey}`
|
|
61435
|
+
);
|
|
61436
|
+
settle4(CREDENTIALS_EXHAUSTED);
|
|
61437
|
+
sendProviderError(
|
|
61438
|
+
res,
|
|
61439
|
+
route,
|
|
61440
|
+
refusal.status,
|
|
61441
|
+
CREDENTIALS_EXHAUSTED,
|
|
61442
|
+
refusal.message,
|
|
61443
|
+
refusal.retryAfterSeconds !== void 0,
|
|
61444
|
+
refusal.retryAfterSeconds
|
|
61445
|
+
);
|
|
60195
61446
|
};
|
|
60196
61447
|
const onError = (failed5, error2) => {
|
|
60197
61448
|
if (settled2 || failed5 !== upstreamReq) return;
|
|
@@ -60394,7 +61645,7 @@ function createModelProxy(deps) {
|
|
|
60394
61645
|
}
|
|
60395
61646
|
};
|
|
60396
61647
|
}
|
|
60397
|
-
var DEFAULT_MAX_REQUEST_BYTES, NOT_FORWARDED_ATTR, DEFAULT_UPSTREAM_IDLE_MS, DEFAULT_BEFORE_FORWARD_TIMEOUT_MS, DEFAULT_UPSTREAM_CONNECT_MS, DEFAULT_REFUSAL_FRAME_WAIT_MS, DEFAULT_PAUSE_HOLD_MS, DEFAULT_PAUSE_STREAM_HOLD_MS, DEFAULT_PAUSE_HOLD_PING_MS, DEFAULT_PAUSE_HOLD_CHECK_MS, MAX_HELD_CALLS_PER_SESSION, PAUSE_HOLD_CODES, ANTHROPIC_PING_EVENT, HELD_STREAM_ERROR_BYTES, FREE_SOCKET_TIMEOUT_MS, KEEP_ALIVE_TIMEOUT_MS, KEEP_ALIVE_MAX_RESPONSE_BYTES, BodyCapture, EXCHANGE_OPEN_BYTES, EXCHANGE_JOIN_BYTES, REQUEST_EFFORT_MAX, CREDENTIAL_MESSAGES;
|
|
61648
|
+
var DEFAULT_MAX_REQUEST_BYTES, NOT_FORWARDED_ATTR, DEFAULT_UPSTREAM_IDLE_MS, DEFAULT_BEFORE_FORWARD_TIMEOUT_MS, DEFAULT_UPSTREAM_CONNECT_MS, DEFAULT_REFUSAL_FRAME_WAIT_MS, DEFAULT_PAUSE_HOLD_MS, DEFAULT_PAUSE_STREAM_HOLD_MS, DEFAULT_PAUSE_HOLD_PING_MS, DEFAULT_PAUSE_HOLD_CHECK_MS, MAX_HELD_CALLS_PER_SESSION, PAUSE_HOLD_CODES, ANTHROPIC_PING_EVENT, HELD_STREAM_ERROR_BYTES, FREE_SOCKET_TIMEOUT_MS, KEEP_ALIVE_TIMEOUT_MS, KEEP_ALIVE_MAX_RESPONSE_BYTES, BodyCapture, EXCHANGE_OPEN_BYTES, EXCHANGE_JOIN_BYTES, REQUEST_EFFORT_MAX, CREDENTIALS_EXHAUSTED, CREDENTIAL_ROTATION_ATTR, EXHAUSTED_RETRY_MAX_MS, FAILURE_WORDS, CREDENTIAL_MESSAGES;
|
|
60398
61649
|
var init_model_proxy = __esm({
|
|
60399
61650
|
"../../packages/tacho/src/collector/model-proxy.ts"() {
|
|
60400
61651
|
"use strict";
|
|
@@ -60409,7 +61660,9 @@ var init_model_proxy = __esm({
|
|
|
60409
61660
|
init_replay_grade();
|
|
60410
61661
|
init_bundle();
|
|
60411
61662
|
init_redaction();
|
|
61663
|
+
init_credential_store();
|
|
60412
61664
|
init_model_credential();
|
|
61665
|
+
init_model_failure();
|
|
60413
61666
|
init_run_token();
|
|
60414
61667
|
init_wire();
|
|
60415
61668
|
init_cache_keep_alive();
|
|
@@ -60469,6 +61722,16 @@ var init_model_proxy = __esm({
|
|
|
60469
61722
|
EXCHANGE_OPEN_BYTES = Buffer.byteLength('{"request":');
|
|
60470
61723
|
EXCHANGE_JOIN_BYTES = Buffer.byteLength(',"response":');
|
|
60471
61724
|
REQUEST_EFFORT_MAX = 32;
|
|
61725
|
+
CREDENTIALS_EXHAUSTED = "credentials_exhausted";
|
|
61726
|
+
CREDENTIAL_ROTATION_ATTR = "oxagen.credential_rotation";
|
|
61727
|
+
EXHAUSTED_RETRY_MAX_MS = 5 * 6e4;
|
|
61728
|
+
FAILURE_WORDS = {
|
|
61729
|
+
rate_limit: "hit a rate limit",
|
|
61730
|
+
usage_limit: "reached its usage limit",
|
|
61731
|
+
credit_exhausted: "has no credit left",
|
|
61732
|
+
invalid_token: "was refused as an invalid token",
|
|
61733
|
+
account_deactivated: "belongs to a deactivated account"
|
|
61734
|
+
};
|
|
60472
61735
|
CREDENTIAL_MESSAGES = {
|
|
60473
61736
|
run_token_malformed: "The credential this call carried is not a run token this Oxagen gateway can read. Run `oxagen agent enroll` again to point the harness at the gateway's run tokens.",
|
|
60474
61737
|
run_token_invalid: "The run token this call carried was not issued by this Oxagen gateway. Run `oxagen credential status` on this machine.",
|
|
@@ -61105,6 +62368,15 @@ function createRequestHandler(api, log, options = {}) {
|
|
|
61105
62368
|
);
|
|
61106
62369
|
return;
|
|
61107
62370
|
}
|
|
62371
|
+
if (path2 === "/credential/sync") {
|
|
62372
|
+
if (api.syncCredentialPools === void 0) {
|
|
62373
|
+
send2(res, 404, { error: "this daemon keeps no credential pool" });
|
|
62374
|
+
return;
|
|
62375
|
+
}
|
|
62376
|
+
const answer = await api.syncCredentialPools();
|
|
62377
|
+
send2(res, answer.status, answer.body);
|
|
62378
|
+
return;
|
|
62379
|
+
}
|
|
61108
62380
|
if (path2 === "/credential/issue") {
|
|
61109
62381
|
if (api.issueRunToken === void 0) {
|
|
61110
62382
|
send2(res, 404, { error: "this daemon issues no run tokens" });
|
|
@@ -62627,7 +63899,16 @@ function cloudGatewayCredentialStore(disk, runToken) {
|
|
|
62627
63899
|
);
|
|
62628
63900
|
},
|
|
62629
63901
|
release: () => void 0,
|
|
62630
|
-
status: () => []
|
|
63902
|
+
status: () => [],
|
|
63903
|
+
// The cloud gateway holds the operator's pool and moves a call through
|
|
63904
|
+
// it itself (`gateway.model.ts`), so a sandbox's gateway holds none.
|
|
63905
|
+
pool: () => [],
|
|
63906
|
+
open: () => void 0,
|
|
63907
|
+
nextUntried: () => void 0,
|
|
63908
|
+
markFailed: () => false,
|
|
63909
|
+
clearFailure: () => false,
|
|
63910
|
+
replaceSecret: () => false,
|
|
63911
|
+
syncPool: () => ({ synced: false, reason: "sandbox" })
|
|
62631
63912
|
};
|
|
62632
63913
|
}
|
|
62633
63914
|
function readTextOrUndefined(path2) {
|
|
@@ -63226,7 +64507,7 @@ async function initializeDaemon(options, server, port, ready, clock2) {
|
|
|
63226
64507
|
return { written: 0, dropped: bodies.length };
|
|
63227
64508
|
}
|
|
63228
64509
|
const placed = placeBodies(bodies, origin);
|
|
63229
|
-
wal.append(events, placed.write,
|
|
64510
|
+
wal.append(events, placed.write, holdOf2(placed.hold));
|
|
63230
64511
|
const evicted = afterPlaced(placed);
|
|
63231
64512
|
stateDirty = true;
|
|
63232
64513
|
for (const event of events)
|
|
@@ -63306,7 +64587,7 @@ async function initializeDaemon(options, server, port, ready, clock2) {
|
|
|
63306
64587
|
}
|
|
63307
64588
|
return evicted;
|
|
63308
64589
|
}
|
|
63309
|
-
function
|
|
64590
|
+
function holdOf2(bodies) {
|
|
63310
64591
|
return bodies.length > 0 ? { bodies, at: now() } : void 0;
|
|
63311
64592
|
}
|
|
63312
64593
|
function heldBoundText() {
|
|
@@ -64807,7 +66088,7 @@ async function initializeDaemon(options, server, port, ready, clock2) {
|
|
|
64807
66088
|
}))
|
|
64808
66089
|
)
|
|
64809
66090
|
);
|
|
64810
|
-
wal.appendRecovered(terminal.events, placed.write,
|
|
66091
|
+
wal.appendRecovered(terminal.events, placed.write, holdOf2(placed.hold));
|
|
64811
66092
|
afterPlaced(placed);
|
|
64812
66093
|
const saved = terminal.state.sessions[0];
|
|
64813
66094
|
const current = saved === void 0 ? void 0 : registry3.list().find(
|
|
@@ -65296,6 +66577,88 @@ async function initializeDaemon(options, server, port, ready, clock2) {
|
|
|
65296
66577
|
}
|
|
65297
66578
|
let startupDaySpend;
|
|
65298
66579
|
let daySpendSeed = Promise.resolve();
|
|
66580
|
+
function custodyRead(read2, fallback) {
|
|
66581
|
+
try {
|
|
66582
|
+
return read2();
|
|
66583
|
+
} catch (error2) {
|
|
66584
|
+
log(
|
|
66585
|
+
`credential store unreadable: ${error2 instanceof Error ? error2.message : String(error2)}; check ${paths.credentials} and ${paths.credentialsKey}, then run \`oxagen credential status\``
|
|
66586
|
+
);
|
|
66587
|
+
return fallback;
|
|
66588
|
+
}
|
|
66589
|
+
}
|
|
66590
|
+
let lastPoolSyncAt = Number.NEGATIVE_INFINITY;
|
|
66591
|
+
const reportCredentialState = createCredentialStateReporter({
|
|
66592
|
+
client,
|
|
66593
|
+
now,
|
|
66594
|
+
log
|
|
66595
|
+
});
|
|
66596
|
+
const chatGptRefresher = createChatGptRefresher({
|
|
66597
|
+
store: credentialStore,
|
|
66598
|
+
fetch: options.fetch ?? fetch,
|
|
66599
|
+
now,
|
|
66600
|
+
refreshed: (member4) => {
|
|
66601
|
+
if (member4.credential_id === void 0) return;
|
|
66602
|
+
if (member4.failure !== void 0 && Date.parse(member4.failure.until) > now())
|
|
66603
|
+
return;
|
|
66604
|
+
reportCredentialState(member4.credential_id, { state: "recovered" });
|
|
66605
|
+
}
|
|
66606
|
+
});
|
|
66607
|
+
const custodyPool = options.cloudGateway !== void 0 ? void 0 : {
|
|
66608
|
+
members: (provider, harness) => custodyRead(() => credentialStore.pool(provider, harness), []),
|
|
66609
|
+
next: (provider, harness, pick4) => custodyRead(
|
|
66610
|
+
() => credentialStore.nextUntried(provider, harness, pick4),
|
|
66611
|
+
void 0
|
|
66612
|
+
),
|
|
66613
|
+
open: (provider, harness, id2) => custodyRead(
|
|
66614
|
+
() => credentialStore.open(provider, harness, id2),
|
|
66615
|
+
void 0
|
|
66616
|
+
),
|
|
66617
|
+
markFailed: (provider, harness, member4, failure4, at2) => {
|
|
66618
|
+
custodyRead(
|
|
66619
|
+
() => credentialStore.markFailed(
|
|
66620
|
+
provider,
|
|
66621
|
+
harness,
|
|
66622
|
+
member4.id,
|
|
66623
|
+
{
|
|
66624
|
+
kind: failure4.kind,
|
|
66625
|
+
until: failure4.until,
|
|
66626
|
+
...failure4.refresh === "rotated" || failure4.refresh === "refused" ? { refreshRefused: failure4.refresh } : {}
|
|
66627
|
+
},
|
|
66628
|
+
at2
|
|
66629
|
+
),
|
|
66630
|
+
false
|
|
66631
|
+
);
|
|
66632
|
+
if (member4.credential_id === void 0) return;
|
|
66633
|
+
if (failure4.refresh === "rotated" || failure4.refresh === "failed")
|
|
66634
|
+
return;
|
|
66635
|
+
reportCredentialState(
|
|
66636
|
+
member4.credential_id,
|
|
66637
|
+
failure4.kind === "invalid_token" || failure4.kind === "account_deactivated" ? { state: "invalid", reason: failure4.kind } : {
|
|
66638
|
+
state: "limited",
|
|
66639
|
+
until: new Date(failure4.until).toISOString()
|
|
66640
|
+
}
|
|
66641
|
+
);
|
|
66642
|
+
},
|
|
66643
|
+
served: (provider, harness, member4) => {
|
|
66644
|
+
custodyRead(
|
|
66645
|
+
() => credentialStore.clearFailure(provider, harness, member4.id),
|
|
66646
|
+
false
|
|
66647
|
+
);
|
|
66648
|
+
if (member4.credential_id !== void 0)
|
|
66649
|
+
reportCredentialState(member4.credential_id, {
|
|
66650
|
+
state: "recovered"
|
|
66651
|
+
});
|
|
66652
|
+
},
|
|
66653
|
+
// Only Codex's slot holds ChatGPT logins.
|
|
66654
|
+
refreshLogin: (provider, harness, member4) => provider === "openai" && harness === "codex" ? chatGptRefresher.refresh(member4.id) : Promise.resolve({
|
|
66655
|
+
outcome: "failed",
|
|
66656
|
+
detail: `${harness} holds no ChatGPT login to refresh`
|
|
66657
|
+
}),
|
|
66658
|
+
// Never to a base URL the harness named itself, such as a
|
|
66659
|
+
// company's own gateway: it would read the person's own keys.
|
|
66660
|
+
copiesServe: (upstream) => displacedUpstreams[upstream] === void 0
|
|
66661
|
+
};
|
|
65299
66662
|
const modelProxy = createModelProxy({
|
|
65300
66663
|
registry: registry3,
|
|
65301
66664
|
hostRecorder: () => hostRecorder,
|
|
@@ -65381,7 +66744,8 @@ async function initializeDaemon(options, server, port, ready, clock2) {
|
|
|
65381
66744
|
host: host.host_enrollment_id,
|
|
65382
66745
|
provider,
|
|
65383
66746
|
now: now()
|
|
65384
|
-
})
|
|
66747
|
+
}),
|
|
66748
|
+
...custodyPool !== void 0 ? { pool: custodyPool } : {}
|
|
65385
66749
|
},
|
|
65386
66750
|
port: () => modelProxyListener.port(),
|
|
65387
66751
|
log,
|
|
@@ -65555,6 +66919,13 @@ async function initializeDaemon(options, server, port, ready, clock2) {
|
|
|
65555
66919
|
...codegraph === void 0 ? {} : {
|
|
65556
66920
|
codegraph: (route, body2) => answerCodeGraphRoute(codegraph, route, body2)
|
|
65557
66921
|
},
|
|
66922
|
+
// A sandbox's daemon keeps no pool, so its route answers 404.
|
|
66923
|
+
...options.cloudGateway === void 0 ? {
|
|
66924
|
+
syncCredentialPools: async () => ({
|
|
66925
|
+
status: 200,
|
|
66926
|
+
body: { pools: await syncPools() }
|
|
66927
|
+
})
|
|
66928
|
+
} : {},
|
|
65558
66929
|
issueRunToken: (input) => issueRunToken(input, {
|
|
65559
66930
|
key: runTokenKey,
|
|
65560
66931
|
store: credentialStore,
|
|
@@ -66159,11 +67530,7 @@ async function initializeDaemon(options, server, port, ready, clock2) {
|
|
|
66159
67530
|
if (harnesses.includes("codex") && now() - lastLoginRefreshAt >= CHATGPT_LOGIN_CHECK_MS) {
|
|
66160
67531
|
lastLoginRefreshAt = now();
|
|
66161
67532
|
try {
|
|
66162
|
-
const refreshed = await
|
|
66163
|
-
credentialStore,
|
|
66164
|
-
options.fetch ?? fetch,
|
|
66165
|
-
now()
|
|
66166
|
-
);
|
|
67533
|
+
const refreshed = await chatGptRefresher.refreshDue();
|
|
66167
67534
|
if (refreshed === "refreshed")
|
|
66168
67535
|
log("refreshed the ChatGPT login in custody");
|
|
66169
67536
|
else if (typeof refreshed === "object")
|
|
@@ -66195,10 +67562,38 @@ async function initializeDaemon(options, server, port, ready, clock2) {
|
|
|
66195
67562
|
log
|
|
66196
67563
|
});
|
|
66197
67564
|
}
|
|
67565
|
+
async function syncPools() {
|
|
67566
|
+
if (options.cloudGateway !== void 0) return [];
|
|
67567
|
+
lastPoolSyncAt = now();
|
|
67568
|
+
const served2 = [];
|
|
67569
|
+
for (const harness of host.harnesses) {
|
|
67570
|
+
const route = POOL_ROUTES[harness];
|
|
67571
|
+
if (route === void 0 || route.upstreams.every((up) => displacedUpstreams[up] === void 0)) {
|
|
67572
|
+
served2.push(harness);
|
|
67573
|
+
continue;
|
|
67574
|
+
}
|
|
67575
|
+
custodyRead(
|
|
67576
|
+
() => credentialStore.syncPool(route.provider, route.harness, [], now()),
|
|
67577
|
+
void 0
|
|
67578
|
+
);
|
|
67579
|
+
}
|
|
67580
|
+
return syncCredentialPools({
|
|
67581
|
+
store: credentialStore,
|
|
67582
|
+
client,
|
|
67583
|
+
harnesses: served2,
|
|
67584
|
+
now,
|
|
67585
|
+
log
|
|
67586
|
+
});
|
|
67587
|
+
}
|
|
67588
|
+
async function syncPoolsWhenDue() {
|
|
67589
|
+
if (now() - lastPoolSyncAt < CREDENTIAL_POOL_SYNC_MS) return;
|
|
67590
|
+
await syncPools();
|
|
67591
|
+
}
|
|
66198
67592
|
async function tick() {
|
|
66199
67593
|
await controlTick();
|
|
66200
67594
|
await renewCertificate();
|
|
66201
67595
|
await renewStaticTokens();
|
|
67596
|
+
await syncPoolsWhenDue();
|
|
66202
67597
|
await gitLane;
|
|
66203
67598
|
}
|
|
66204
67599
|
let timer;
|
|
@@ -66209,7 +67604,7 @@ async function initializeDaemon(options, server, port, ready, clock2) {
|
|
|
66209
67604
|
if (pendingSessionEnds.size > 0) void startGitReads();
|
|
66210
67605
|
if (ticking) return;
|
|
66211
67606
|
ticking = true;
|
|
66212
|
-
controlTick().then(() => renewCertificate()).then(() => renewStaticTokens()).catch((error2) => {
|
|
67607
|
+
controlTick().then(() => renewCertificate()).then(() => renewStaticTokens()).then(() => syncPoolsWhenDue()).catch((error2) => {
|
|
66213
67608
|
const code = error2 instanceof Error && "code" in error2 ? ` [${String(error2.code)}]` : "";
|
|
66214
67609
|
const site = error2 instanceof Error && typeof error2.stack === "string" ? error2.stack.split("\n")[1]?.trim() ?? "" : "";
|
|
66215
67610
|
log(
|
|
@@ -66464,7 +67859,7 @@ async function initializeDaemon(options, server, port, ready, clock2) {
|
|
|
66464
67859
|
}
|
|
66465
67860
|
};
|
|
66466
67861
|
}
|
|
66467
|
-
var IDLE_COMMAND_POLL_FACTOR, DEFAULT_TIMERS, STATIC_TOKEN_RENEWAL_CHECK_MS, CERTIFICATE_RENEWAL_RETRY_MS, CHATGPT_LOGIN_CHECK_MS, MEMORY_SCAN_MS, CLOUD_GATEWAY_ORIGIN, CLOUD_GATEWAY_BASE_PATH, QUEUED_PROMPT_CLASS, TRACE_DRAIN_TIMEOUT_MS, RECORDER_EVENTS_KEPT, owedBodyPurgeSchema, objectSchema, spoolFileSchema, otlpResourceListSchema, otlpPayloadSchema, defaultExecAsync, STOPPING, STOPPED_EXEC, STATE_WRITE_DEFER_MS;
|
|
67862
|
+
var IDLE_COMMAND_POLL_FACTOR, DEFAULT_TIMERS, STATIC_TOKEN_RENEWAL_CHECK_MS, CERTIFICATE_RENEWAL_RETRY_MS, CHATGPT_LOGIN_CHECK_MS, MEMORY_SCAN_MS, CLOUD_GATEWAY_ORIGIN, CLOUD_GATEWAY_BASE_PATH, POOL_ROUTES, QUEUED_PROMPT_CLASS, TRACE_DRAIN_TIMEOUT_MS, RECORDER_EVENTS_KEPT, owedBodyPurgeSchema, objectSchema, spoolFileSchema, otlpResourceListSchema, otlpPayloadSchema, defaultExecAsync, STOPPING, STOPPED_EXEC, STATE_WRITE_DEFER_MS;
|
|
66468
67863
|
var init_daemon = __esm({
|
|
66469
67864
|
"../../packages/tacho/src/collector/daemon.ts"() {
|
|
66470
67865
|
"use strict";
|
|
@@ -66490,6 +67885,7 @@ var init_daemon = __esm({
|
|
|
66490
67885
|
init_model_credential();
|
|
66491
67886
|
init_static_token_renewal();
|
|
66492
67887
|
init_chatgpt_refresh();
|
|
67888
|
+
init_credential_pool();
|
|
66493
67889
|
init_run_token();
|
|
66494
67890
|
init_process_scan();
|
|
66495
67891
|
init_retention();
|
|
@@ -66582,6 +67978,23 @@ var init_daemon = __esm({
|
|
|
66582
67978
|
MEMORY_SCAN_MS = 5 * 6e4;
|
|
66583
67979
|
CLOUD_GATEWAY_ORIGIN = "https://api.oxagen.sh";
|
|
66584
67980
|
CLOUD_GATEWAY_BASE_PATH = "/v1/gateway";
|
|
67981
|
+
POOL_ROUTES = {
|
|
67982
|
+
"claude-code": {
|
|
67983
|
+
provider: "anthropic",
|
|
67984
|
+
harness: "claude-code",
|
|
67985
|
+
upstreams: ["anthropic"]
|
|
67986
|
+
},
|
|
67987
|
+
stella: {
|
|
67988
|
+
provider: "anthropic",
|
|
67989
|
+
harness: "stella",
|
|
67990
|
+
upstreams: ["anthropic"]
|
|
67991
|
+
},
|
|
67992
|
+
codex: {
|
|
67993
|
+
provider: "openai",
|
|
67994
|
+
harness: "codex",
|
|
67995
|
+
upstreams: ["openai", "chatgpt"]
|
|
67996
|
+
}
|
|
67997
|
+
};
|
|
66585
67998
|
QUEUED_PROMPT_CLASS = RETENTION_CLASS_BY_KIND["oxagen:message"] ?? "model_call";
|
|
66586
67999
|
TRACE_DRAIN_TIMEOUT_MS = 1e4;
|
|
66587
68000
|
RECORDER_EVENTS_KEPT = 64;
|
|
@@ -67621,7 +69034,7 @@ async function daemonRoute(deps, route, body2) {
|
|
|
67621
69034
|
}
|
|
67622
69035
|
return { status: answer.status, body: parsed2 };
|
|
67623
69036
|
}
|
|
67624
|
-
function
|
|
69037
|
+
function errorOf2(body2, status2) {
|
|
67625
69038
|
const error2 = body2?.error;
|
|
67626
69039
|
return typeof error2 === "string" ? error2 : `the daemon answered HTTP ${status2}`;
|
|
67627
69040
|
}
|
|
@@ -67631,7 +69044,7 @@ function daemonLink(deps) {
|
|
|
67631
69044
|
if (answer === void 0)
|
|
67632
69045
|
throw new CodegraphCommandError("the daemon stopped answering");
|
|
67633
69046
|
if (answer.status < 200 || answer.status >= 300)
|
|
67634
|
-
throw new CodegraphCommandError(
|
|
69047
|
+
throw new CodegraphCommandError(errorOf2(answer.body, answer.status));
|
|
67635
69048
|
return answer.body;
|
|
67636
69049
|
};
|
|
67637
69050
|
return {
|
|
@@ -67817,7 +69230,7 @@ async function codegraphStop(options, deps) {
|
|
|
67817
69230
|
const answer = await daemonRoute(deps, "stop", {}).catch(() => void 0);
|
|
67818
69231
|
if (answer !== void 0 && (answer.status < 200 || answer.status >= 300)) {
|
|
67819
69232
|
deps.err(
|
|
67820
|
-
`oxagen graph: the daemon did not stop the code graph server: ${
|
|
69233
|
+
`oxagen graph: the daemon did not stop the code graph server: ${errorOf2(answer.body, answer.status)}`
|
|
67821
69234
|
);
|
|
67822
69235
|
return false;
|
|
67823
69236
|
}
|
|
@@ -67873,11 +69286,13 @@ __export(cli_exports, {
|
|
|
67873
69286
|
credentialIssue: () => credentialIssue,
|
|
67874
69287
|
credentialLogin: () => credentialLogin,
|
|
67875
69288
|
credentialStatus: () => credentialStatus,
|
|
69289
|
+
credentialSync: () => credentialSync,
|
|
67876
69290
|
cursorAppFacts: () => cursorAppFacts,
|
|
67877
69291
|
cursorFacts: () => cursorFacts,
|
|
67878
69292
|
dataLocalDir: () => dataLocalDir,
|
|
67879
69293
|
defaultCliDeps: () => defaultCliDeps,
|
|
67880
69294
|
describeHarness: () => describeHarness,
|
|
69295
|
+
describePoolSync: () => describePoolSync,
|
|
67881
69296
|
describeRepo: () => describeRepo,
|
|
67882
69297
|
detect: () => detect,
|
|
67883
69298
|
disarmGateway: () => disarmGateway,
|
|
@@ -67936,6 +69351,7 @@ __export(cli_exports, {
|
|
|
67936
69351
|
stopGateway: () => stopGateway,
|
|
67937
69352
|
streamDaemon: () => streamDaemon,
|
|
67938
69353
|
stripEnrollmentHooks: () => stripEnrollmentHooks,
|
|
69354
|
+
syncCredentialPoolsNow: () => syncCredentialPoolsNow,
|
|
67939
69355
|
transientBinDir: () => transientBinDir,
|
|
67940
69356
|
unenroll: () => unenroll,
|
|
67941
69357
|
unenrollTarget: () => unenrollTarget,
|
|
@@ -73149,6 +74565,15 @@ function buildTachoProgram(options = {}) {
|
|
|
73149
74565
|
if (!outcome.ok) process.exitCode = 1;
|
|
73150
74566
|
}
|
|
73151
74567
|
);
|
|
74568
|
+
credential.command("sync").description(
|
|
74569
|
+
"Read the model credentials you saved in Oxagen into the gateway's custody now, so a call moves to the next one when a provider refuses the one in use"
|
|
74570
|
+
).option("--json", "Machine-readable output").action(async (opts) => {
|
|
74571
|
+
const outcome = await credentialSync(
|
|
74572
|
+
{ ...opts.json !== void 0 ? { json: opts.json } : {} },
|
|
74573
|
+
deps
|
|
74574
|
+
);
|
|
74575
|
+
if (!outcome.ok) process.exitCode = 1;
|
|
74576
|
+
});
|
|
73152
74577
|
credential.command("status").description(
|
|
73153
74578
|
"Which providers the gateway holds, and how each harness gets its credential"
|
|
73154
74579
|
).option("--json", "Machine-readable output").action(async (opts) => {
|
|
@@ -73448,7 +74873,7 @@ var init_package = __esm({
|
|
|
73448
74873
|
"package.json"() {
|
|
73449
74874
|
package_default = {
|
|
73450
74875
|
name: "@oxagen/cli",
|
|
73451
|
-
version: "3.0.1-
|
|
74876
|
+
version: "3.0.1-818",
|
|
73452
74877
|
description: "Oxagen governance CLI: spend, source tracking, grounding, credentials, and audit (agentic coding lives in the stella CLI)",
|
|
73453
74878
|
type: "module",
|
|
73454
74879
|
main: "./dist/index.js",
|
|
@@ -76472,7 +77897,7 @@ var init_common = __esm({
|
|
|
76472
77897
|
function call(name2, request3, result2) {
|
|
76473
77898
|
return { call: name2, request: request3, result: result2, response: responseSchema(result2) };
|
|
76474
77899
|
}
|
|
76475
|
-
var unit3, count8, names, excluded, withinSchema, testRefSchema, SEARCH_GROUPS, searchHitSchema, SEARCH_MEANING_STATES, searchMeaningStateSchema, searchCodeGraphRequest, searchCodeGraphResult, blastTargetSchema, decisionItemSchema, blastGroupsSchema, getBlastRadiusRequest, getBlastRadiusResult, listUnitTestsRequest, listUnitTestsResult, flowDataSchema, flowNodeSchema, jobStepSchema, getExecutionFlowRequest, getExecutionFlowResult, traceSpecRequest, traceSpecResult, listGoverningDecisionsBase, listGoverningDecisionsRequest, listGoverningDecisionsResult, getEnvVarsRequest, getEnvVarsResult, connectionSchema, getInfraRequest, getInfraResult, listCiJobsRequest, listCiJobsResult, scriptEffectSchema, listScriptsRequest, listScriptsResult, getApiDocsRequest, getApiDocsResult, exportOpenapiDraftRequest, exportOpenapiDraftResult, listCoChangesRequest, listCoChangesResult, rankSymbolsRequest, rankSymbolsResult, getRepoMapRequest, getRepoMapResult, getDomainBriefRequest, getDomainBriefResult, checkChangeRequest, checkChangeResult, findDefinitionRequest, findDefinitionResult, findReferencesRequest, findReferencesResult, findImplementationsRequest, findImplementationsResult, listNeighborsRequest, listNeighborsResult, failureRefSchema, FAILURE_KINDS,
|
|
77900
|
+
var unit3, count8, names, excluded, withinSchema, testRefSchema, SEARCH_GROUPS, searchHitSchema, SEARCH_MEANING_STATES, searchMeaningStateSchema, searchCodeGraphRequest, searchCodeGraphResult, blastTargetSchema, decisionItemSchema, blastGroupsSchema, getBlastRadiusRequest, getBlastRadiusResult, listUnitTestsRequest, listUnitTestsResult, flowDataSchema, flowNodeSchema, jobStepSchema, getExecutionFlowRequest, getExecutionFlowResult, traceSpecRequest, traceSpecResult, listGoverningDecisionsBase, listGoverningDecisionsRequest, listGoverningDecisionsResult, getEnvVarsRequest, getEnvVarsResult, connectionSchema, getInfraRequest, getInfraResult, listCiJobsRequest, listCiJobsResult, scriptEffectSchema, listScriptsRequest, listScriptsResult, getApiDocsRequest, getApiDocsResult, exportOpenapiDraftRequest, exportOpenapiDraftResult, listCoChangesRequest, listCoChangesResult, rankSymbolsRequest, rankSymbolsResult, getRepoMapRequest, getRepoMapResult, getDomainBriefRequest, getDomainBriefResult, checkChangeRequest, checkChangeResult, findDefinitionRequest, findDefinitionResult, findReferencesRequest, findReferencesResult, findImplementationsRequest, findImplementationsResult, listNeighborsRequest, listNeighborsResult, failureRefSchema, FAILURE_KINDS, failureSchema2, DATAFLOW_EDGE_KINDS, SLICE_DIRECTIONS, SLICE_ROLES, SLICE_MAX_DEPTH, sliceStepSchema, dataflowSliceBase, getDataflowSliceRequest, getDataflowSliceResult, FAULT_SIGNALS, LOCALIZE_MAX_SUSPECTS, signalEvidenceSchema, suspectSchema, localizeFaultBase, localizeFaultRequest, localizeFaultResult, INTENT_EVIDENCE_KINDS, intentEvidenceSchema, getIntendedBehaviorRequest, getIntendedBehaviorResult, REPAIR_CONTEXT_SECTIONS, REPAIR_CONTEXT_DEFAULT_BUDGET, REPAIR_CONTEXT_MAX_BUDGET, repairContextSectionSchema, repairContextBase, getRepairContextRequest, getRepairContextResult, CODEGRAPH_CALLS;
|
|
76476
77901
|
var init_calls = __esm({
|
|
76477
77902
|
"../../packages/codegraph/src/query/calls.ts"() {
|
|
76478
77903
|
"use strict";
|
|
@@ -77000,7 +78425,7 @@ var init_calls = __esm({
|
|
|
77000
78425
|
"broken_decision",
|
|
77001
78426
|
"drifted_spec"
|
|
77002
78427
|
];
|
|
77003
|
-
|
|
78428
|
+
failureSchema2 = external_exports.object({
|
|
77004
78429
|
id: external_exports.string().min(1).optional(),
|
|
77005
78430
|
kind: external_exports.enum(FAILURE_KINDS).optional(),
|
|
77006
78431
|
/** The exception type, the top frames inside the repo, and the test id. */
|
|
@@ -77111,7 +78536,7 @@ var init_calls = __esm({
|
|
|
77111
78536
|
{ message: "pass a failure, an issue's text, or a stack trace" }
|
|
77112
78537
|
);
|
|
77113
78538
|
localizeFaultResult = external_exports.object({
|
|
77114
|
-
failure:
|
|
78539
|
+
failure: failureSchema2.optional(),
|
|
77115
78540
|
suspects: external_exports.array(suspectSchema),
|
|
77116
78541
|
/** Each signal, whether it ran, and why not when it did not. */
|
|
77117
78542
|
signals: external_exports.array(
|
|
@@ -77195,7 +78620,7 @@ var init_calls = __esm({
|
|
|
77195
78620
|
{ message: "pass suspects or a failure" }
|
|
77196
78621
|
);
|
|
77197
78622
|
getRepairContextResult = external_exports.object({
|
|
77198
|
-
failure:
|
|
78623
|
+
failure: failureSchema2.optional(),
|
|
77199
78624
|
sections: external_exports.array(repairContextSectionSchema),
|
|
77200
78625
|
/** On a replay: the share of the fix's lines inside the bundle. */
|
|
77201
78626
|
coverageAtBudget: unit3.optional(),
|
|
@@ -92455,9 +93880,11 @@ __export(host_exports, {
|
|
|
92455
93880
|
DEVICE_KEY_PROOF_DOMAIN: () => DEVICE_KEY_PROOF_DOMAIN,
|
|
92456
93881
|
ENROLLMENT_CERTIFICATE_TTL_S: () => ENROLLMENT_CERTIFICATE_TTL_S,
|
|
92457
93882
|
HARNESS_PROVIDER: () => HARNESS_PROVIDER,
|
|
93883
|
+
HELD_MEMBER_ID: () => HELD_MEMBER_ID,
|
|
92458
93884
|
HOST_FILE_SCHEMA: () => HOST_FILE_SCHEMA,
|
|
92459
93885
|
HTTP_HOOK_EVENTS: () => HTTP_HOOK_EVENTS,
|
|
92460
93886
|
LEGACY_CREATED_WANTS_MARK: () => LEGACY_CREATED_WANTS_MARK,
|
|
93887
|
+
LOGIN_REFRESH_REFUSALS: () => LOGIN_REFRESH_REFUSALS,
|
|
92461
93888
|
REQUEST_SIGNATURE_DOMAIN: () => REQUEST_SIGNATURE_DOMAIN,
|
|
92462
93889
|
REQUEST_SIGNATURE_HEADER: () => REQUEST_SIGNATURE_HEADER,
|
|
92463
93890
|
REQUEST_SIGNATURE_MAX_SKEW_S: () => REQUEST_SIGNATURE_MAX_SKEW_S,
|
|
@@ -92471,6 +93898,7 @@ __export(host_exports, {
|
|
|
92471
93898
|
SCHTASKS_NAME: () => SCHTASKS_NAME,
|
|
92472
93899
|
SERVICE_LABEL: () => SERVICE_LABEL,
|
|
92473
93900
|
SESSION_END_TIMEOUT_S: () => SESSION_END_TIMEOUT_S,
|
|
93901
|
+
SETUP_TOKEN_EXIT_MARK: () => SETUP_TOKEN_EXIT_MARK,
|
|
92474
93902
|
SPOOLED_HOOK_EVENTS: () => SPOOLED_HOOK_EVENTS,
|
|
92475
93903
|
STATIC_TOKEN_HARNESSES: () => STATIC_TOKEN_HARNESSES,
|
|
92476
93904
|
STATIC_TOKEN_RENEW_WINDOW_MS: () => STATIC_TOKEN_RENEW_WINDOW_MS,
|
|
@@ -92484,6 +93912,7 @@ __export(host_exports, {
|
|
|
92484
93912
|
TACHO_ENV_KEYS: () => TACHO_ENV_KEYS,
|
|
92485
93913
|
TACHO_INGEST_TIMEOUT_MS: () => TACHO_INGEST_TIMEOUT_MS,
|
|
92486
93914
|
TACHO_LOCAL_TOKEN_ENV: () => TACHO_LOCAL_TOKEN_ENV,
|
|
93915
|
+
VAULT_POOL_SOURCE: () => VAULT_POOL_SOURCE,
|
|
92487
93916
|
Wal: () => Wal,
|
|
92488
93917
|
WalRecoveryConflict: () => WalRecoveryConflict,
|
|
92489
93918
|
absoluteHookCommandProblem: () => absoluteHookCommandProblem,
|
|
@@ -92535,7 +93964,10 @@ __export(host_exports, {
|
|
|
92535
93964
|
ensureDir: () => ensureDir,
|
|
92536
93965
|
envOf: () => envOf,
|
|
92537
93966
|
evaluatePreToolUse: () => evaluatePreToolUse,
|
|
93967
|
+
extractSetupToken: () => extractSetupToken,
|
|
92538
93968
|
fileVersion: () => fileVersion,
|
|
93969
|
+
findClaudeBinary: () => findClaudeBinary,
|
|
93970
|
+
findHarnessBinary: () => findHarnessBinary,
|
|
92539
93971
|
foldMcpServerCase: () => foldMcpServerCase,
|
|
92540
93972
|
formatDaemonPid: () => formatDaemonPid,
|
|
92541
93973
|
frameListLength: () => frameListLength,
|
|
@@ -92558,8 +93990,10 @@ __export(host_exports, {
|
|
|
92558
93990
|
hostFileSchema: () => hostFileSchema,
|
|
92559
93991
|
hostStatusInForce: () => hostStatusInForce,
|
|
92560
93992
|
isDaemonImage: () => isDaemonImage,
|
|
93993
|
+
isLoginKind: () => isLoginKind,
|
|
92561
93994
|
isModelProxyBaseUrl: () => isModelProxyBaseUrl,
|
|
92562
93995
|
isProcessAlive: () => isProcessAlive,
|
|
93996
|
+
isSubscriptionToken: () => isSubscriptionToken,
|
|
92563
93997
|
isTachoEntry: () => isTachoEntry,
|
|
92564
93998
|
isTachoGroup: () => isTachoGroup,
|
|
92565
93999
|
isTachoHelper: () => isTachoHelper,
|
|
@@ -92628,12 +94062,15 @@ __export(host_exports, {
|
|
|
92628
94062
|
restoreModelCredentials: () => restoreModelCredentials,
|
|
92629
94063
|
revokedSubjectDigest: () => revokedSubjectDigest,
|
|
92630
94064
|
ruleMatches: () => ruleMatches,
|
|
94065
|
+
runClaudeSetupToken: () => runClaudeSetupToken,
|
|
92631
94066
|
runTokenKeyFromHex: () => runTokenKeyFromHex,
|
|
92632
94067
|
serializeJsonLike: () => serializeJsonLike,
|
|
92633
94068
|
serviceManagerFor: () => serviceManagerFor,
|
|
92634
94069
|
sessionScopeForEnrollment: () => sessionScopeForEnrollment,
|
|
92635
94070
|
sessionScopeOf: () => sessionScopeOf,
|
|
92636
94071
|
settingsShapeProblem: () => settingsShapeProblem,
|
|
94072
|
+
setupTokenCommand: () => setupTokenCommand,
|
|
94073
|
+
setupTokenShellLine: () => setupTokenShellLine,
|
|
92637
94074
|
shellSegments: () => shellSegments,
|
|
92638
94075
|
sidecarBeside: () => sidecarBeside,
|
|
92639
94076
|
signBytes: () => signBytes,
|
|
@@ -92685,6 +94122,7 @@ var init_host = __esm({
|
|
|
92685
94122
|
"use strict";
|
|
92686
94123
|
init_agents();
|
|
92687
94124
|
init_bundle();
|
|
94125
|
+
init_claude_setup_token();
|
|
92688
94126
|
init_codex_writer();
|
|
92689
94127
|
init_control_client();
|
|
92690
94128
|
init_credential_store();
|
|
@@ -92741,12 +94179,12 @@ async function detectHarnesses(deps = {}) {
|
|
|
92741
94179
|
const names2 = commandNames(HARNESS_BINARY[harness], platform2);
|
|
92742
94180
|
const path2 = dirs.flatMap((dir) => names2.map((name2) => join65(dir, name2))).find(isExecutable2);
|
|
92743
94181
|
if (path2 !== void 0) {
|
|
92744
|
-
found.push({ harness, label:
|
|
94182
|
+
found.push({ harness, label: harnessLabel2(harness), path: path2 });
|
|
92745
94183
|
}
|
|
92746
94184
|
}
|
|
92747
94185
|
return found;
|
|
92748
94186
|
}
|
|
92749
|
-
function
|
|
94187
|
+
function harnessLabel2(harness) {
|
|
92750
94188
|
return TACHO_HARNESS_LABELS[harness];
|
|
92751
94189
|
}
|
|
92752
94190
|
function isWrapped(name2) {
|
|
@@ -93099,7 +94537,7 @@ async function agentConnect(opts, writer = stdoutWriter, deps = {}) {
|
|
|
93099
94537
|
);
|
|
93100
94538
|
}
|
|
93101
94539
|
const ref = `${preview.org.slug}/${preview.workspace.slug}`;
|
|
93102
|
-
const label = isDeviceHarness(preview.agent.harness) ?
|
|
94540
|
+
const label = isDeviceHarness(preview.agent.harness) ? harnessLabel2(preview.agent.harness) : preview.agent.harness;
|
|
93103
94541
|
if (preview.state === "connected") {
|
|
93104
94542
|
if (!preview.connectedHere)
|
|
93105
94543
|
return out.error(
|
|
@@ -93888,7 +95326,7 @@ async function harnessesToConnect(opts, ref, interactive, deps, out) {
|
|
|
93888
95326
|
}
|
|
93889
95327
|
return parsed2.harnesses.map((harness) => ({
|
|
93890
95328
|
harness,
|
|
93891
|
-
label:
|
|
95329
|
+
label: harnessLabel2(harness)
|
|
93892
95330
|
}));
|
|
93893
95331
|
}
|
|
93894
95332
|
let installed;
|
|
@@ -110454,14 +111892,21 @@ __export(credentials_exports, {
|
|
|
110454
111892
|
LOGIN_HARNESSES: () => LOGIN_HARNESSES,
|
|
110455
111893
|
PROVIDERS: () => PROVIDERS,
|
|
110456
111894
|
SecretAborted: () => SecretAborted,
|
|
110457
|
-
|
|
110458
|
-
|
|
111895
|
+
createBodyOf: () => createBodyOf,
|
|
111896
|
+
createSetupTokenHider: () => createSetupTokenHider,
|
|
111897
|
+
credentialsCreate: () => credentialsCreate,
|
|
110459
111898
|
credentialsList: () => credentialsList,
|
|
110460
111899
|
credentialsRemove: () => credentialsRemove,
|
|
110461
111900
|
credentialsRotate: () => credentialsRotate,
|
|
110462
111901
|
credentialsUpdate: () => credentialsUpdate,
|
|
110463
|
-
|
|
111902
|
+
hideSetupToken: () => hideSetupToken,
|
|
111903
|
+
readCodexAuthFile: () => readCodexAuthFile,
|
|
111904
|
+
readSecret: () => readSecret,
|
|
111905
|
+
runHarnessLogin: () => runHarnessLogin
|
|
110464
111906
|
});
|
|
111907
|
+
import { spawn as spawn8 } from "node:child_process";
|
|
111908
|
+
import { homedir as homedir14 } from "node:os";
|
|
111909
|
+
import { join as join68 } from "node:path";
|
|
110465
111910
|
function sharedBody(opts) {
|
|
110466
111911
|
return opts.shared ? { scope: "workspace" } : {};
|
|
110467
111912
|
}
|
|
@@ -110520,22 +111965,22 @@ function scopeFor(opts) {
|
|
|
110520
111965
|
const ws = namedWorkspace(opts.workspaceSlug) ?? getWorkspaceId();
|
|
110521
111966
|
if (!ws) {
|
|
110522
111967
|
return {
|
|
110523
|
-
error: "
|
|
111968
|
+
error: opts.shared ? "A workspace account belongs to one workspace. Run `oxagen workspace use <org/workspace>` to choose it, or name one with --workspace-slug <slug> or OXAGEN_WORKSPACE." : "Your credentials belong to you, not to a workspace, but the API still addresses them through one. Run `oxagen workspace use <org/workspace>` to choose the workspace this call goes through, or name one with --workspace-slug <slug> or OXAGEN_WORKSPACE."
|
|
110524
111969
|
};
|
|
110525
111970
|
}
|
|
110526
111971
|
const org = getOrgId();
|
|
110527
111972
|
if (!org) return { error: NO_ORG };
|
|
110528
111973
|
return { org, ws };
|
|
110529
111974
|
}
|
|
110530
|
-
function
|
|
110531
|
-
const
|
|
111975
|
+
function createBodyOf(opts) {
|
|
111976
|
+
const harness = opts.harness;
|
|
111977
|
+
const type = opts.type ?? (harness !== void 0 ? "subscription" : "api-key");
|
|
110532
111978
|
if (!(type in AUTH_TYPES)) {
|
|
110533
111979
|
return {
|
|
110534
111980
|
error: `Pass --type with one of: ${Object.keys(AUTH_TYPES).join(", ")}.`
|
|
110535
111981
|
};
|
|
110536
111982
|
}
|
|
110537
111983
|
const authType = AUTH_TYPES[type];
|
|
110538
|
-
const harness = opts.harness;
|
|
110539
111984
|
if (harness !== void 0 && !LOGIN_HARNESSES.includes(harness)) {
|
|
110540
111985
|
return {
|
|
110541
111986
|
error: harness === "cursor" ? "Cursor's model calls do not pass through the gateway, so Oxagen cannot use a Cursor login." : `Pass --harness with one of: ${LOGIN_HARNESSES.join(", ")}.`
|
|
@@ -110543,7 +111988,7 @@ function addBodyOf(opts) {
|
|
|
110543
111988
|
}
|
|
110544
111989
|
if (opts.baseUrl !== void 0 && opts.provider !== CUSTOM_ENDPOINT_PROVIDER) {
|
|
110545
111990
|
return {
|
|
110546
|
-
error: `Only --provider ${CUSTOM_ENDPOINT_PROVIDER} takes --base-url. Anthropic and
|
|
111991
|
+
error: `Only --provider ${CUSTOM_ENDPOINT_PROVIDER} takes --base-url. Anthropic, OpenAI, and OpenRouter keys use the vendor's own endpoint.`
|
|
110547
111992
|
};
|
|
110548
111993
|
}
|
|
110549
111994
|
if (authType === "subscription_token") {
|
|
@@ -110568,7 +112013,9 @@ function addBodyOf(opts) {
|
|
|
110568
112013
|
}
|
|
110569
112014
|
const provider = opts.provider;
|
|
110570
112015
|
if (!provider || !PROVIDERS.includes(provider)) {
|
|
110571
|
-
return {
|
|
112016
|
+
return {
|
|
112017
|
+
error: `Pass --provider with one of: ${PROVIDERS.join(", ")} to save a key, or --harness with one of: ${LOGIN_HARNESSES.join(", ")} to save a login.`
|
|
112018
|
+
};
|
|
110572
112019
|
}
|
|
110573
112020
|
if (provider === CUSTOM_ENDPOINT_PROVIDER) {
|
|
110574
112021
|
const baseUrl = opts.baseUrl?.trim();
|
|
@@ -110595,26 +112042,178 @@ function addBodyOf(opts) {
|
|
|
110595
112042
|
...opts.label ? { label: opts.label } : {}
|
|
110596
112043
|
};
|
|
110597
112044
|
}
|
|
110598
|
-
|
|
112045
|
+
function hideSetupToken(chunk) {
|
|
112046
|
+
return chunk.replace(SETUP_TOKEN_ON_SCREEN, "sk-ant-oat\u2026 (sent to Oxagen)");
|
|
112047
|
+
}
|
|
112048
|
+
function createSetupTokenHider(write) {
|
|
112049
|
+
let held = "";
|
|
112050
|
+
return {
|
|
112051
|
+
push(chunk) {
|
|
112052
|
+
const text6 = held + chunk;
|
|
112053
|
+
const tail = SETUP_TOKEN_TAIL.exec(text6);
|
|
112054
|
+
const cut = tail === null ? text6.length : tail.index;
|
|
112055
|
+
held = text6.slice(cut);
|
|
112056
|
+
if (cut > 0) write(hideSetupToken(text6.slice(0, cut)));
|
|
112057
|
+
},
|
|
112058
|
+
end() {
|
|
112059
|
+
if (held !== "") write(hideSetupToken(held));
|
|
112060
|
+
held = "";
|
|
112061
|
+
}
|
|
112062
|
+
};
|
|
112063
|
+
}
|
|
112064
|
+
function spawnCodexLogin(codex) {
|
|
112065
|
+
return new Promise((resolve29, reject) => {
|
|
112066
|
+
const child = spawn8(codex, ["login"], {
|
|
112067
|
+
stdio: ["inherit", 2, "inherit"],
|
|
112068
|
+
env: process.env
|
|
112069
|
+
});
|
|
112070
|
+
child.on("error", reject);
|
|
112071
|
+
child.on("close", (code) => resolve29(code ?? 1));
|
|
112072
|
+
});
|
|
112073
|
+
}
|
|
112074
|
+
async function runHarnessLogin(harness) {
|
|
112075
|
+
const host = await Promise.resolve().then(() => (init_host(), host_exports));
|
|
112076
|
+
if (harness === "claude-code") {
|
|
112077
|
+
const claude = host.findClaudeBinary(process.env, homedir14());
|
|
112078
|
+
if (claude === void 0) return { found: false };
|
|
112079
|
+
const screen = createSetupTokenHider((text6) => {
|
|
112080
|
+
process.stderr.write(text6);
|
|
112081
|
+
});
|
|
112082
|
+
const run3 = await host.runClaudeSetupToken({
|
|
112083
|
+
claude,
|
|
112084
|
+
interactive: true,
|
|
112085
|
+
write: screen.push
|
|
112086
|
+
});
|
|
112087
|
+
screen.end();
|
|
112088
|
+
return { found: true, code: run3.code, token: run3.token };
|
|
112089
|
+
}
|
|
112090
|
+
const codex = host.findHarnessBinary("codex", process.env, homedir14());
|
|
112091
|
+
if (codex === void 0) return { found: false };
|
|
112092
|
+
return { found: true, code: await spawnCodexLogin(codex), token: void 0 };
|
|
112093
|
+
}
|
|
112094
|
+
async function readCodexAuthFile() {
|
|
112095
|
+
const host = await Promise.resolve().then(() => (init_host(), host_exports));
|
|
112096
|
+
const path2 = join68(host.codexHomeFor(process.env, homedir14()), "auth.json");
|
|
112097
|
+
return { path: path2, text: host.readTextIfExists(path2) };
|
|
112098
|
+
}
|
|
112099
|
+
function keyFlagOf(key) {
|
|
112100
|
+
if (key === void 0) return { kind: "none" };
|
|
112101
|
+
const value = key.trim();
|
|
112102
|
+
if (value === "-") return { kind: "stdin" };
|
|
112103
|
+
if (value === "") {
|
|
112104
|
+
return {
|
|
112105
|
+
error: "--key needs the key, or - to read it from standard input."
|
|
112106
|
+
};
|
|
112107
|
+
}
|
|
112108
|
+
return { kind: "literal", value };
|
|
112109
|
+
}
|
|
112110
|
+
function whatOf(body2) {
|
|
112111
|
+
if (body2.authType === "subscription_token") return `${body2.harness} login`;
|
|
112112
|
+
if (body2.baseUrl !== void 0) return `key for ${body2.baseUrl}`;
|
|
112113
|
+
return `${body2.provider} credential`;
|
|
112114
|
+
}
|
|
112115
|
+
async function claudeLogin(out, read2, deps) {
|
|
112116
|
+
out.info("Running `claude setup-token`. Finish the sign-in in your browser.");
|
|
112117
|
+
const run3 = await (deps.runLogin ?? runHarnessLogin)("claude-code");
|
|
112118
|
+
if (!run3.found) {
|
|
112119
|
+
return {
|
|
112120
|
+
failure: "Claude Code is not installed, so `claude setup-token` cannot run. Install it, or pipe the token in: oxagen credentials create --harness claude-code --key -",
|
|
112121
|
+
code: "login"
|
|
112122
|
+
};
|
|
112123
|
+
}
|
|
112124
|
+
if (run3.code !== 0) {
|
|
112125
|
+
return {
|
|
112126
|
+
failure: `\`claude setup-token\` exited with ${run3.code}. Nothing was saved.`,
|
|
112127
|
+
code: "login"
|
|
112128
|
+
};
|
|
112129
|
+
}
|
|
112130
|
+
if (run3.token !== void 0) return { secret: run3.token };
|
|
112131
|
+
out.info(
|
|
112132
|
+
"The sign-in finished, but Oxagen could not read the token off its screen."
|
|
112133
|
+
);
|
|
112134
|
+
return { secret: await read2("Paste the token `claude setup-token` printed") };
|
|
112135
|
+
}
|
|
112136
|
+
async function codexLogin2(out, deps) {
|
|
112137
|
+
const readFile8 = deps.readCodexAuth ?? readCodexAuthFile;
|
|
112138
|
+
const saved = await readFile8();
|
|
112139
|
+
if (saved.text !== void 0) {
|
|
112140
|
+
out.info(`Using the Codex login in ${saved.path}.`);
|
|
112141
|
+
return { secret: saved.text.trim() };
|
|
112142
|
+
}
|
|
112143
|
+
out.info("Running `codex login`. Finish the sign-in in your browser.");
|
|
112144
|
+
const run3 = await (deps.runLogin ?? runHarnessLogin)("codex");
|
|
112145
|
+
if (!run3.found) {
|
|
112146
|
+
return {
|
|
112147
|
+
failure: `Codex is not installed, so \`codex login\` cannot run. Install it, or pipe a login in: ${CODEX_PIPE}`,
|
|
112148
|
+
code: "login"
|
|
112149
|
+
};
|
|
112150
|
+
}
|
|
112151
|
+
if (run3.code !== 0) {
|
|
112152
|
+
return {
|
|
112153
|
+
failure: `\`codex login\` exited with ${run3.code}. Nothing was saved.`,
|
|
112154
|
+
code: "login"
|
|
112155
|
+
};
|
|
112156
|
+
}
|
|
112157
|
+
const made = await readFile8();
|
|
112158
|
+
if (made.text === void 0) {
|
|
112159
|
+
return {
|
|
112160
|
+
failure: `\`codex login\` finished, but ${made.path} does not exist. Nothing was saved.`,
|
|
112161
|
+
code: "login"
|
|
112162
|
+
};
|
|
112163
|
+
}
|
|
112164
|
+
return { secret: made.text.trim() };
|
|
112165
|
+
}
|
|
112166
|
+
async function secretFor(body2, key, isTty, out, deps) {
|
|
112167
|
+
const read2 = deps.readSecret ?? readSecret;
|
|
112168
|
+
try {
|
|
112169
|
+
if (key.kind === "literal") return { secret: key.value };
|
|
112170
|
+
if (key.kind === "none" && isTty) {
|
|
112171
|
+
if (body2.harness === "claude-code") {
|
|
112172
|
+
return await claudeLogin(out, read2, deps);
|
|
112173
|
+
}
|
|
112174
|
+
if (body2.harness === "codex") return await codexLogin2(out, deps);
|
|
112175
|
+
}
|
|
112176
|
+
return { secret: await read2(`Paste the ${whatOf(body2)}`) };
|
|
112177
|
+
} catch (err2) {
|
|
112178
|
+
return {
|
|
112179
|
+
failure: err2,
|
|
112180
|
+
code: err2 instanceof SecretAborted ? "cancelled" : "input"
|
|
112181
|
+
};
|
|
112182
|
+
}
|
|
112183
|
+
}
|
|
112184
|
+
function notUsedYet(credential) {
|
|
112185
|
+
if (credential.authType === "subscription_token") {
|
|
112186
|
+
return credential.harness === "codex" ? "Codex runs don't use a ChatGPT login yet" : void 0;
|
|
112187
|
+
}
|
|
112188
|
+
return credential.provider === "openrouter" || credential.baseUrl ? "Sandbox runs don't use this key yet" : void 0;
|
|
112189
|
+
}
|
|
112190
|
+
function savedLine(credential, shared) {
|
|
112191
|
+
const what = credential.authType === "subscription_token" ? `the ${credential.harness ?? credential.provider} login` : credential.provider === "openrouter" ? "the openrouter key" : credential.baseUrl ? `the key for ${credential.baseUrl}` : `the ${credential.provider} key`;
|
|
112192
|
+
const saved = `Saved ${what} ending ${credential.hint} as ${credential.id}.`;
|
|
112193
|
+
const idle = notUsedYet(credential);
|
|
112194
|
+
if (shared) {
|
|
112195
|
+
return idle === void 0 ? `${saved} Runs whose account source names this workspace can use it.` : `${saved} It belongs to this workspace. ${idle}, and Oxagen keeps it until they do.`;
|
|
112196
|
+
}
|
|
112197
|
+
return idle === void 0 ? `${saved} Your runs in every workspace can use it.` : `${saved} It is yours in every workspace. ${idle}, and Oxagen keeps it until they do.`;
|
|
112198
|
+
}
|
|
112199
|
+
async function credentialsCreate(opts, writer = stdoutWriter, deps = {}) {
|
|
110599
112200
|
const out = createOutput({ json: opts.json }, writer);
|
|
110600
|
-
const body2 =
|
|
112201
|
+
const body2 = createBodyOf(opts);
|
|
110601
112202
|
if ("error" in body2) return out.error(body2.error, "usage");
|
|
110602
|
-
const
|
|
110603
|
-
if (
|
|
112203
|
+
const key = keyFlagOf(opts.key);
|
|
112204
|
+
if ("error" in key) return out.error(key.error, "usage");
|
|
112205
|
+
const isTty = (deps.isTty ?? (() => process.stdin.isTTY === true))();
|
|
112206
|
+
if (body2.harness === "codex" && (key.kind === "literal" || key.kind === "stdin" && isTty)) {
|
|
110604
112207
|
return out.error(
|
|
110605
|
-
|
|
112208
|
+
`A ChatGPT login is a file, so an argument or a prompt cannot carry it. Pipe it in: ${CODEX_PIPE}. To sign in on this terminal instead, leave out --key.`,
|
|
110606
112209
|
"usage"
|
|
110607
112210
|
);
|
|
110608
112211
|
}
|
|
110609
112212
|
const scope = scopeFor(opts);
|
|
110610
112213
|
if ("error" in scope) return out.error(scope.error, "usage");
|
|
110611
|
-
const
|
|
110612
|
-
|
|
110613
|
-
|
|
110614
|
-
secret = await (deps.readSecret ?? readSecret)(`Paste the ${what}`);
|
|
110615
|
-
} catch (err2) {
|
|
110616
|
-
return out.error(err2, err2 instanceof SecretAborted ? "cancelled" : "input");
|
|
110617
|
-
}
|
|
112214
|
+
const got = await secretFor(body2, key, isTty, out, deps);
|
|
112215
|
+
if ("failure" in got) return out.error(got.failure, got.code);
|
|
112216
|
+
const { secret } = got;
|
|
110618
112217
|
if (secret.length < MIN_SECRET || secret.length > MAX_SECRET) {
|
|
110619
112218
|
return out.error(
|
|
110620
112219
|
`A credential is ${MIN_SECRET} to ${MAX_SECRET} characters. Nothing was stored.`,
|
|
@@ -110627,16 +112226,15 @@ async function credentialsAdd(opts, writer = stdoutWriter, deps = {}) {
|
|
|
110627
112226
|
{ ...body2, ...sharedBody(opts), secret },
|
|
110628
112227
|
scope
|
|
110629
112228
|
);
|
|
110630
|
-
if (out.isJson) {
|
|
110631
|
-
|
|
110632
|
-
|
|
110633
|
-
}
|
|
110634
|
-
writer.write(
|
|
110635
|
-
credential.baseUrl ? `Stored the key ending ${credential.hint} for ${credential.baseUrl} as ${credential.id}. Sandbox runs don't use your own endpoint yet. Oxagen keeps the key until they do.` : opts.shared ? `Stored the ${credential.provider} account ending ${credential.hint} as ${credential.id}. Runs whose account source names this workspace can use it.` : `Stored the ${credential.provider} credential ending ${credential.hint} as ${credential.id}. Only your own runs use it.`
|
|
110636
|
-
);
|
|
112229
|
+
if (out.isJson) out.data({ credential });
|
|
112230
|
+
else writer.write(savedLine(credential, opts.shared === true));
|
|
112231
|
+
if (key.kind === "literal") writer.writeErr(KEY_IN_HISTORY);
|
|
110637
112232
|
} catch (err2) {
|
|
110638
112233
|
const refusal = refusalOf3(err2);
|
|
110639
|
-
out.error(
|
|
112234
|
+
out.error(
|
|
112235
|
+
refusal.reason === "model_credential_duplicate" ? `${refusal.message} Run \`oxagen credentials list\` to see your credentials.` : refusal.message,
|
|
112236
|
+
refusal.reason ?? "api"
|
|
112237
|
+
);
|
|
110640
112238
|
}
|
|
110641
112239
|
}
|
|
110642
112240
|
async function credentialsList(opts, writer = stdoutWriter) {
|
|
@@ -110655,7 +112253,7 @@ async function credentialsList(opts, writer = stdoutWriter) {
|
|
|
110655
112253
|
}
|
|
110656
112254
|
if (items.length === 0) {
|
|
110657
112255
|
writer.write(
|
|
110658
|
-
"You have no model credentials in Oxagen.
|
|
112256
|
+
"You have no model credentials in Oxagen. Save one with `oxagen credentials create --harness claude-code` or `oxagen credentials create --provider anthropic`."
|
|
110659
112257
|
);
|
|
110660
112258
|
return;
|
|
110661
112259
|
}
|
|
@@ -110777,7 +112375,7 @@ async function credentialsRotate(credentialId, opts, writer = stdoutWriter, deps
|
|
|
110777
112375
|
}
|
|
110778
112376
|
if (current.authType !== "api_key") {
|
|
110779
112377
|
return out.error(
|
|
110780
|
-
"This credential is a subscription login, so it has no key to rotate.
|
|
112378
|
+
"This credential is a subscription login, so it has no key to rotate. Create the new login, then remove this one.",
|
|
110781
112379
|
"model_credential_not_rotatable"
|
|
110782
112380
|
);
|
|
110783
112381
|
}
|
|
@@ -110847,7 +112445,7 @@ async function credentialsRemove(credentialId, opts, writer = stdoutWriter) {
|
|
|
110847
112445
|
out.error(refusal.message, refusal.reason ?? "api");
|
|
110848
112446
|
}
|
|
110849
112447
|
}
|
|
110850
|
-
var PROVIDERS, CUSTOM_ENDPOINT_PROVIDER, AUTH_TYPES, LOGIN_HARNESSES, LOGIN_PROVIDER, MIN_SECRET, MAX_SECRET, CREDENTIAL_ID, SecretAborted;
|
|
112448
|
+
var PROVIDERS, CUSTOM_ENDPOINT_PROVIDER, AUTH_TYPES, LOGIN_HARNESSES, LOGIN_PROVIDER, MIN_SECRET, MAX_SECRET, CREDENTIAL_ID, SecretAborted, SETUP_TOKEN_ON_SCREEN, SETUP_TOKEN_START, SETUP_TOKEN_TAIL, KEY_IN_HISTORY, CODEX_PIPE;
|
|
110851
112449
|
var init_credentials = __esm({
|
|
110852
112450
|
"src/commands/credentials.ts"() {
|
|
110853
112451
|
init_api();
|
|
@@ -110855,7 +112453,12 @@ var init_credentials = __esm({
|
|
|
110855
112453
|
init_capture_writer();
|
|
110856
112454
|
init_output();
|
|
110857
112455
|
init_sandbox_run();
|
|
110858
|
-
PROVIDERS = [
|
|
112456
|
+
PROVIDERS = [
|
|
112457
|
+
"anthropic",
|
|
112458
|
+
"openai",
|
|
112459
|
+
"openrouter",
|
|
112460
|
+
"openai_compatible"
|
|
112461
|
+
];
|
|
110859
112462
|
CUSTOM_ENDPOINT_PROVIDER = "openai_compatible";
|
|
110860
112463
|
AUTH_TYPES = {
|
|
110861
112464
|
"api-key": "api_key",
|
|
@@ -110872,6 +112475,16 @@ var init_credentials = __esm({
|
|
|
110872
112475
|
this.name = "SecretAborted";
|
|
110873
112476
|
}
|
|
110874
112477
|
};
|
|
112478
|
+
SETUP_TOKEN_ON_SCREEN = /sk-ant-oat[A-Za-z0-9_-]*/g;
|
|
112479
|
+
SETUP_TOKEN_START = "sk-ant-oat";
|
|
112480
|
+
SETUP_TOKEN_TAIL = new RegExp(
|
|
112481
|
+
`(?:${Array.from(
|
|
112482
|
+
{ length: SETUP_TOKEN_START.length - 1 },
|
|
112483
|
+
(_, i2) => SETUP_TOKEN_START.slice(0, i2 + 1)
|
|
112484
|
+
).join("|")}|${SETUP_TOKEN_START}[A-Za-z0-9_-]*)$`
|
|
112485
|
+
);
|
|
112486
|
+
KEY_IN_HISTORY = "The key you typed is in your shell history and visible in the process list. Next time, pass --key - to read it from standard input, or leave out --key for a hidden prompt.";
|
|
112487
|
+
CODEX_PIPE = "oxagen credentials create --harness codex --key - < ~/.codex/auth.json";
|
|
110875
112488
|
}
|
|
110876
112489
|
});
|
|
110877
112490
|
|
|
@@ -111875,7 +113488,7 @@ import {
|
|
|
111875
113488
|
statSync as statSync20,
|
|
111876
113489
|
writeFileSync as writeFileSync11
|
|
111877
113490
|
} from "node:fs";
|
|
111878
|
-
import { dirname as dirname36, join as
|
|
113491
|
+
import { dirname as dirname36, join as join69 } from "node:path";
|
|
111879
113492
|
function isBundleName(name2) {
|
|
111880
113493
|
return BUNDLE_FILES.has(name2) || isClaimBundleName(name2);
|
|
111881
113494
|
}
|
|
@@ -111887,7 +113500,7 @@ function readDirectoryEntries(dir) {
|
|
|
111887
113500
|
const entries2 = /* @__PURE__ */ new Map();
|
|
111888
113501
|
const walk2 = (folder, prefix) => {
|
|
111889
113502
|
for (const entry2 of readdirSync18(folder)) {
|
|
111890
|
-
const path2 =
|
|
113503
|
+
const path2 = join69(folder, entry2);
|
|
111891
113504
|
const name2 = `${prefix}${entry2}`;
|
|
111892
113505
|
if (statSync20(path2).isDirectory()) {
|
|
111893
113506
|
if (prefix === "" && (entry2 === "heads" || entry2 === "trust"))
|
|
@@ -112119,7 +113732,7 @@ async function writeSampleBundle(dir, writer = stdoutWriter) {
|
|
|
112119
113732
|
const { files: files2, pins } = buildSampleClaimBundle();
|
|
112120
113733
|
const zipped = {};
|
|
112121
113734
|
for (const [name2, bytes] of files2) {
|
|
112122
|
-
const path2 =
|
|
113735
|
+
const path2 = join69(dir, name2);
|
|
112123
113736
|
mkdirSync14(dirname36(path2), { recursive: true });
|
|
112124
113737
|
writeFileSync11(path2, bytes);
|
|
112125
113738
|
zipped[name2] = bytes;
|
|
@@ -130230,7 +131843,7 @@ var init_conversation = __esm({
|
|
|
130230
131843
|
});
|
|
130231
131844
|
|
|
130232
131845
|
// src/auth/open-browser.ts
|
|
130233
|
-
import { spawn as
|
|
131846
|
+
import { spawn as spawn9 } from "node:child_process";
|
|
130234
131847
|
function openBrowser(url2) {
|
|
130235
131848
|
try {
|
|
130236
131849
|
let cmd;
|
|
@@ -130248,7 +131861,7 @@ function openBrowser(url2) {
|
|
|
130248
131861
|
cmd = "xdg-open";
|
|
130249
131862
|
args = [url2];
|
|
130250
131863
|
}
|
|
130251
|
-
const child =
|
|
131864
|
+
const child = spawn9(cmd, args, { detached: true, stdio: "ignore" });
|
|
130252
131865
|
child.on("error", () => {
|
|
130253
131866
|
});
|
|
130254
131867
|
child.unref();
|
|
@@ -150887,7 +152500,7 @@ function deadlineExceeded(deadline_ms) {
|
|
|
150887
152500
|
status: void 0
|
|
150888
152501
|
};
|
|
150889
152502
|
}
|
|
150890
|
-
function
|
|
152503
|
+
function retryAfterMs2(value, now) {
|
|
150891
152504
|
if (value === void 0) return void 0;
|
|
150892
152505
|
const text6 = value.trim();
|
|
150893
152506
|
if (/^\d+$/.test(text6)) return Number(text6) * 1e3;
|
|
@@ -151411,38 +153024,38 @@ async function attemptOnce(spec, deadline) {
|
|
|
151411
153024
|
const response = sent.value;
|
|
151412
153025
|
const read2 = await readBody3(response, { clock: clock2, deadline_ms });
|
|
151413
153026
|
if (!read2.ok) return { attempt: read2, exchange: void 0 };
|
|
151414
|
-
const
|
|
153027
|
+
const exchange2 = {
|
|
151415
153028
|
request: spec.recorded,
|
|
151416
153029
|
response: recordHttpResponse(response, read2.bytes)
|
|
151417
153030
|
};
|
|
151418
153031
|
const attempt = spec.interpret(response, read2.bytes);
|
|
151419
153032
|
if (!attempt.ok && spec.retryable && RETRY_STATUSES.has(response.status)) {
|
|
151420
|
-
const after_ms =
|
|
153033
|
+
const after_ms = retryAfterMs2(
|
|
151421
153034
|
headerValue(response.headers, "retry-after"),
|
|
151422
153035
|
Date.now()
|
|
151423
153036
|
);
|
|
151424
153037
|
return {
|
|
151425
153038
|
attempt: { ok: false, error: attempt.error, retry: { after_ms } },
|
|
151426
|
-
exchange
|
|
153039
|
+
exchange: exchange2
|
|
151427
153040
|
};
|
|
151428
153041
|
}
|
|
151429
|
-
return { attempt, exchange };
|
|
153042
|
+
return { attempt, exchange: exchange2 };
|
|
151430
153043
|
} finally {
|
|
151431
153044
|
clock2.dispose();
|
|
151432
153045
|
}
|
|
151433
153046
|
}
|
|
151434
153047
|
async function runHttp(spec) {
|
|
151435
153048
|
const deadline = Date.now() + spec.context.shaping.deadline_ms;
|
|
151436
|
-
let
|
|
153049
|
+
let exchange2;
|
|
151437
153050
|
const result2 = await withRetries(
|
|
151438
153051
|
async () => {
|
|
151439
153052
|
const outcome = await attemptOnce(spec, deadline);
|
|
151440
|
-
|
|
153053
|
+
exchange2 = outcome.exchange;
|
|
151441
153054
|
return outcome.attempt;
|
|
151442
153055
|
},
|
|
151443
153056
|
{ deadline, signal: spec.context.signal, backoff_ms: spec.backoff_ms }
|
|
151444
153057
|
);
|
|
151445
|
-
const exchanges =
|
|
153058
|
+
const exchanges = exchange2 === void 0 ? [] : [exchange2];
|
|
151446
153059
|
return result2.ok ? { ok: true, value: result2.value, attempts: result2.attempts, exchanges } : { ok: false, error: result2.error, attempts: result2.attempts, exchanges };
|
|
151447
153060
|
}
|
|
151448
153061
|
var KEPT_RESERVED, RETRY_STATUSES, MAX_DETAIL;
|
|
@@ -151629,7 +153242,7 @@ async function rejected(session, response, setup) {
|
|
|
151629
153242
|
}
|
|
151630
153243
|
function rejectedAttempt(response, failure4) {
|
|
151631
153244
|
if (!failure4.retry) return { ok: false, error: failure4.error };
|
|
151632
|
-
const after_ms =
|
|
153245
|
+
const after_ms = retryAfterMs2(
|
|
151633
153246
|
headerValue(response.headers, "retry-after"),
|
|
151634
153247
|
Date.now()
|
|
151635
153248
|
);
|
|
@@ -151859,16 +153472,16 @@ async function attemptOnce2(call2, deadline) {
|
|
|
151859
153472
|
}
|
|
151860
153473
|
async function runAttempts(context, backoff_ms, attempt) {
|
|
151861
153474
|
const deadline = Date.now() + context.shaping.deadline_ms;
|
|
151862
|
-
let
|
|
153475
|
+
let exchange2;
|
|
151863
153476
|
const result2 = await withRetries(
|
|
151864
153477
|
async () => {
|
|
151865
153478
|
const outcome = await attempt(deadline);
|
|
151866
|
-
|
|
153479
|
+
exchange2 = outcome.exchange;
|
|
151867
153480
|
return outcome.attempt;
|
|
151868
153481
|
},
|
|
151869
153482
|
{ deadline, signal: context.signal, backoff_ms }
|
|
151870
153483
|
);
|
|
151871
|
-
const exchanges =
|
|
153484
|
+
const exchanges = exchange2 === void 0 ? [] : [exchange2];
|
|
151872
153485
|
return result2.ok ? { ok: true, value: result2.value, attempts: result2.attempts, exchanges } : { ok: false, error: result2.error, attempts: result2.attempts, exchanges };
|
|
151873
153486
|
}
|
|
151874
153487
|
function createMcpSender(options = {}) {
|
|
@@ -154042,10 +155655,10 @@ function scrubJson(value, secrets) {
|
|
|
154042
155655
|
function scrubSent(sent, secrets) {
|
|
154043
155656
|
if (secrets.length === 0) return sent;
|
|
154044
155657
|
const exchanges = sent.exchanges?.map(
|
|
154045
|
-
(
|
|
154046
|
-
...
|
|
155658
|
+
(exchange2) => ({
|
|
155659
|
+
...exchange2,
|
|
154047
155660
|
response: scrubJson(
|
|
154048
|
-
|
|
155661
|
+
exchange2.response,
|
|
154049
155662
|
secrets
|
|
154050
155663
|
)
|
|
154051
155664
|
})
|
|
@@ -172341,21 +173954,21 @@ function replayTransport(exchanges, route) {
|
|
|
172341
173954
|
problem ??= found;
|
|
172342
173955
|
throw new TransportError("unsupported", found.message, false);
|
|
172343
173956
|
};
|
|
172344
|
-
const wrongKind = (
|
|
173957
|
+
const wrongKind = (exchange2, response, needed, reason3) => {
|
|
172345
173958
|
const recorded = responseKind(response);
|
|
172346
173959
|
return refuse3({
|
|
172347
173960
|
part: "response",
|
|
172348
|
-
exchange,
|
|
173961
|
+
exchange: exchange2,
|
|
172349
173962
|
expected: recorded,
|
|
172350
173963
|
actual: needed,
|
|
172351
|
-
message: `Exchange ${
|
|
173964
|
+
message: `Exchange ${exchange2} records ${recorded}, but ${reason3}.`
|
|
172352
173965
|
});
|
|
172353
173966
|
};
|
|
172354
173967
|
const take = () => {
|
|
172355
173968
|
const again = retryable ? exchanges[next - 1] : void 0;
|
|
172356
173969
|
if (again !== void 0) return again.response;
|
|
172357
|
-
const
|
|
172358
|
-
if (
|
|
173970
|
+
const exchange2 = exchanges[next];
|
|
173971
|
+
if (exchange2 === void 0) {
|
|
172359
173972
|
return refuse3({
|
|
172360
173973
|
part: "exchanges",
|
|
172361
173974
|
exchange: next + 1,
|
|
@@ -172366,7 +173979,7 @@ function replayTransport(exchanges, route) {
|
|
|
172366
173979
|
}
|
|
172367
173980
|
next += 1;
|
|
172368
173981
|
retryable = false;
|
|
172369
|
-
return
|
|
173982
|
+
return exchange2.response;
|
|
172370
173983
|
};
|
|
172371
173984
|
const takeHttp = () => {
|
|
172372
173985
|
const response = take();
|
|
@@ -172535,8 +174148,8 @@ async function replayCall(server, call2) {
|
|
|
172535
174148
|
}
|
|
172536
174149
|
const problem = replay.problem();
|
|
172537
174150
|
if (problem !== void 0) {
|
|
172538
|
-
const { part, exchange, expected, actual, message: message2 } = problem;
|
|
172539
|
-
return differs({ part, exchange, path: "", expected, actual, message: message2 });
|
|
174151
|
+
const { part, exchange: exchange2, expected, actual, message: message2 } = problem;
|
|
174152
|
+
return differs({ part, exchange: exchange2, path: "", expected, actual, message: message2 });
|
|
172540
174153
|
}
|
|
172541
174154
|
const used = replay.used();
|
|
172542
174155
|
if (used !== call2.exchanges.length) {
|
|
@@ -173419,9 +175032,9 @@ async function replayFolder(name2, text6, tools, manifest) {
|
|
|
173419
175032
|
const result2 = await replayCall(manifest, call2);
|
|
173420
175033
|
if (result2.status === "skipped") tally2.skipped.push(result2.reason);
|
|
173421
175034
|
if (result2.status !== "differs") continue;
|
|
173422
|
-
const { part, exchange, message: message2 } = result2.difference;
|
|
175035
|
+
const { part, exchange: exchange2, message: message2 } = result2.difference;
|
|
173423
175036
|
const detail = { tool: call2.tool, part };
|
|
173424
|
-
if (
|
|
175037
|
+
if (exchange2 !== void 0) detail.exchange = exchange2;
|
|
173425
175038
|
findings.push(replayFinding(path2, index, call2, message2, detail));
|
|
173426
175039
|
}
|
|
173427
175040
|
return { findings, notes: replayNotes(path2, tally2) };
|
|
@@ -175139,7 +176752,7 @@ import {
|
|
|
175139
176752
|
readlinkSync as readlinkSync4,
|
|
175140
176753
|
statSync as statSync21
|
|
175141
176754
|
} from "node:fs";
|
|
175142
|
-
import { dirname as dirname37, isAbsolute as isAbsolute19, join as
|
|
176755
|
+
import { dirname as dirname37, isAbsolute as isAbsolute19, join as join70, relative as relative10, resolve as resolve28, sep as sep13 } from "node:path";
|
|
175143
176756
|
function cloneRepoKind(root) {
|
|
175144
176757
|
const out = git4(root, ["remote", "get-url", "origin"]);
|
|
175145
176758
|
const url2 = out?.toString("utf8").trim() ?? "";
|
|
@@ -175179,7 +176792,7 @@ function commitOf(root, ref) {
|
|
|
175179
176792
|
return sha2.length > 0 ? sha2 : null;
|
|
175180
176793
|
}
|
|
175181
176794
|
function readWorkingFile(root, path2) {
|
|
175182
|
-
const abs =
|
|
176795
|
+
const abs = join70(root, ...path2.split("/"));
|
|
175183
176796
|
try {
|
|
175184
176797
|
const stat7 = lstatSync14(abs);
|
|
175185
176798
|
if (stat7.isSymbolicLink()) return readlinkSync4(abs, "utf8");
|
|
@@ -175273,7 +176886,7 @@ function isDir(path2) {
|
|
|
175273
176886
|
function findSteeringRoot(start) {
|
|
175274
176887
|
let dir = resolve28(start);
|
|
175275
176888
|
for (; ; ) {
|
|
175276
|
-
if (isFile(
|
|
176889
|
+
if (isFile(join70(dir, WORKSPACE_TOML_PATH)) || isFile(join70(dir, AGENTS_MD_PATH)) && isDir(join70(dir, STEERING_DIR))) {
|
|
175277
176890
|
return dir;
|
|
175278
176891
|
}
|
|
175279
176892
|
const parent = dirname37(dir);
|
|
@@ -175353,7 +176966,7 @@ function cacheFile(cacheDir, root) {
|
|
|
175353
176966
|
key: token === void 0 ? null : createHash31("sha256").update(token).digest("hex").slice(0, 16)
|
|
175354
176967
|
};
|
|
175355
176968
|
const key = createHash31("sha256").update(JSON.stringify([root, identity])).digest("hex").slice(0, 32);
|
|
175356
|
-
return
|
|
176969
|
+
return join70(cacheDir, `${key}.json`);
|
|
175357
176970
|
}
|
|
175358
176971
|
function readCache(file, now) {
|
|
175359
176972
|
let entry2;
|
|
@@ -175467,7 +177080,7 @@ function defaultDeps2() {
|
|
|
175467
177080
|
return {
|
|
175468
177081
|
fetchPublished: fetchSteeringIndex,
|
|
175469
177082
|
cedar: cedarHooks,
|
|
175470
|
-
cacheDir:
|
|
177083
|
+
cacheDir: join70(getConfigDir(), "cache", "steering-check"),
|
|
175471
177084
|
now: () => Date.now()
|
|
175472
177085
|
};
|
|
175473
177086
|
}
|
|
@@ -178541,19 +180154,25 @@ function buildProgram() {
|
|
|
178541
180154
|
});
|
|
178542
180155
|
addRuntimeCommands(program2);
|
|
178543
180156
|
const credentialsCmd = program2.command("credentials").alias("keys").description(
|
|
178544
|
-
"Manage your
|
|
180157
|
+
"Manage your model credentials: API keys and Claude or ChatGPT logins. They belong to your account, so every workspace you work in can use them. The gateway attaches them to your runs and never puts one in a sandbox. Also named keys"
|
|
178545
180158
|
);
|
|
178546
|
-
credentialsCmd.command("add").description(
|
|
178547
|
-
"
|
|
178548
|
-
).option(
|
|
180159
|
+
credentialsCmd.command("create").alias("add").description(
|
|
180160
|
+
"Save a credential on your account. With --harness it runs the harness's own sign-in and saves the login. With --provider it saves an API key. Several for one harness or provider are fine. Also named add"
|
|
180161
|
+
).option(
|
|
180162
|
+
"--harness <name>",
|
|
180163
|
+
"Save the login of claude-code or codex. Runs the harness's own sign-in when no login is saved"
|
|
180164
|
+
).option(
|
|
178549
180165
|
"--provider <name>",
|
|
178550
|
-
"anthropic, openai, or openai_compatible for your own endpoint
|
|
180166
|
+
"Save an API key for anthropic, openai, openrouter, or openai_compatible for your own endpoint"
|
|
180167
|
+
).option(
|
|
180168
|
+
"--key <value>",
|
|
180169
|
+
"The API key. Use - to read it from standard input. A key typed here stays in your shell history, so leave it out for a hidden prompt"
|
|
180170
|
+
).option(
|
|
180171
|
+
"--type <type>",
|
|
180172
|
+
"api-key or subscription (default: subscription with --harness, otherwise api-key)"
|
|
178551
180173
|
).option(
|
|
178552
180174
|
"--base-url <url>",
|
|
178553
180175
|
"The https address of your own endpoint, with --provider openai_compatible"
|
|
178554
|
-
).option(
|
|
178555
|
-
"--harness <name>",
|
|
178556
|
-
"The harness a subscription login is for: claude-code or codex"
|
|
178557
180176
|
).option(
|
|
178558
180177
|
"--label <name>",
|
|
178559
180178
|
"A name for the credential, such as the account's email"
|
|
@@ -178564,7 +180183,7 @@ function buildProgram() {
|
|
|
178564
180183
|
"--shared",
|
|
178565
180184
|
"Act on this workspace's accounts instead of your own. Changing one needs a workspace Admin or an organization Owner"
|
|
178566
180185
|
).option("--json", "Output JSON").action(
|
|
178567
|
-
async (opts) => (await Promise.resolve().then(() => (init_credentials(), credentials_exports))).
|
|
180186
|
+
async (opts) => (await Promise.resolve().then(() => (init_credentials(), credentials_exports))).credentialsCreate(opts)
|
|
178568
180187
|
);
|
|
178569
180188
|
credentialsCmd.command("list").description("List your credentials in the order the gateway uses them").option(
|
|
178570
180189
|
"--workspace-slug <slug>",
|
|
@@ -179370,6 +180989,7 @@ var init_program = __esm({
|
|
|
179370
180989
|
"--token",
|
|
179371
180990
|
"--input",
|
|
179372
180991
|
"--endpoint",
|
|
180992
|
+
"--key",
|
|
179373
180993
|
// `oxagen agent connect --request <token>` carries an enrollment token.
|
|
179374
180994
|
"--request"
|
|
179375
180995
|
]);
|