@openllmsh/sdk 0.0.0-stage → 2.10.12-alpha.1
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/ARCHITECTURE.md +43 -0
- package/LICENSE +202 -0
- package/README.md +142 -2
- package/assets/openllm-light.svg +18 -0
- package/assets/openllm.svg +18 -0
- package/client/chat.ts +140 -0
- package/client/devices.ts +269 -0
- package/client/http.ts +72 -0
- package/client/index.ts +129 -0
- package/client/relay-mux.ts +547 -0
- package/client/types.ts +51 -0
- package/client/vault.ts +239 -0
- package/connect/chat.ts +58 -0
- package/connect/client.ts +240 -0
- package/connect/config.ts +47 -0
- package/connect/errors.ts +121 -0
- package/connect/index.ts +23 -0
- package/connect/oauth.ts +265 -0
- package/connect/routes.ts +234 -0
- package/connect/store.ts +107 -0
- package/mcp/handle.ts +24 -0
- package/mcp/index.ts +76 -0
- package/mcp/server.ts +319 -0
- package/mcp/tools/marketplace.ts +439 -0
- package/mcp/tools/memory-client.ts +297 -0
- package/mcp/tools/memory-config.ts +32 -0
- package/mcp/tools/memory.ts +369 -0
- package/mcp/tools/model-priority.ts +88 -0
- package/mcp/tools/openllm.ts +883 -0
- package/mcp/types.ts +28 -0
- package/openapi/call.ts +90 -0
- package/openapi/index.ts +8 -0
- package/openapi/openapi.json +80213 -0
- package/openapi/operations.ts +2075 -0
- package/package.json +39 -4
- package/protocol/CONTRIBUTING.md +21 -0
- package/protocol/README.md +134 -0
- package/protocol/access.ts +186 -0
- package/protocol/agent-prompt-text.ts +32 -0
- package/protocol/agent.ts +991 -0
- package/protocol/api-key-syntax.ts +105 -0
- package/protocol/assets/openllm-light.svg +18 -0
- package/protocol/assets/openllm.svg +18 -0
- package/protocol/audio.ts +29 -0
- package/protocol/auth.ts +142 -0
- package/protocol/changelog.ts +155 -0
- package/protocol/chat.ts +458 -0
- package/protocol/client-registry.ts +356 -0
- package/protocol/config.ts +345 -0
- package/protocol/control-channel.ts +115 -0
- package/protocol/cooldown-reason.ts +78 -0
- package/protocol/cost.ts +10 -0
- package/protocol/daemon-port.ts +31 -0
- package/protocol/daemon.ts +1524 -0
- package/protocol/default-chains.ts +66 -0
- package/protocol/device-state.ts +85 -0
- package/protocol/doctor-report-local.ts +443 -0
- package/protocol/doctor-report-policy.ts +119 -0
- package/protocol/doctor-report.ts +947 -0
- package/protocol/errors.ts +14 -0
- package/protocol/execution-selection.ts +141 -0
- package/protocol/hop-grant.ts +33 -0
- package/protocol/image-edit-parse.ts +263 -0
- package/protocol/images.ts +298 -0
- package/protocol/index.ts +74 -0
- package/protocol/inference-headers.ts +3 -0
- package/protocol/keepalive.ts +69 -0
- package/protocol/local-auth.ts +300 -0
- package/protocol/local-device-control.ts +133 -0
- package/protocol/local-provider.ts +288 -0
- package/protocol/local-session.ts +118 -0
- package/protocol/marketplace.ts +187 -0
- package/protocol/media-attempt.ts +81 -0
- package/protocol/media-bytes.ts +28 -0
- package/protocol/media-default.ts +357 -0
- package/protocol/media-dimensions.ts +132 -0
- package/protocol/media-input.ts +61 -0
- package/protocol/media-model.ts +142 -0
- package/protocol/media-option-issue.ts +90 -0
- package/protocol/media-types.ts +70 -0
- package/protocol/model-match.ts +1051 -0
- package/protocol/model-settings.ts +327 -0
- package/protocol/models.ts +767 -0
- package/protocol/mux.ts +722 -0
- package/protocol/plan-surface.ts +59 -0
- package/protocol/provider-models.ts +16 -0
- package/protocol/provider-status.ts +206 -0
- package/protocol/provider-tier.ts +67 -0
- package/protocol/provider-usage.ts +263 -0
- package/protocol/providers.ts +901 -0
- package/protocol/public-usage-index.ts +354 -0
- package/protocol/realtime-generated.ts +31 -0
- package/protocol/realtime.ts +324 -0
- package/protocol/registry-pointer.ts +118 -0
- package/protocol/relay.ts +702 -0
- package/protocol/replay-session.ts +11 -0
- package/protocol/responses.ts +280 -0
- package/protocol/semver.ts +182 -0
- package/protocol/setup-mode.ts +22 -0
- package/protocol/sha256-hex.ts +98 -0
- package/protocol/stats.ts +406 -0
- package/protocol/streaming.ts +19 -0
- package/protocol/subscription-daemon-floors.ts +33 -0
- package/protocol/subscription-provider-compat.ts +104 -0
- package/protocol/subscription-provider.ts +32 -0
- package/protocol/team-grant.ts +17 -0
- package/protocol/team-shareable.ts +61 -0
- package/protocol/transcription-encoding.ts +76 -0
- package/protocol/url-locality-dns.ts +37 -0
- package/protocol/url-locality.ts +288 -0
- package/protocol/usage-snapshots.ts +9 -0
- package/protocol/vendor-cli-install.ts +29 -0
- package/protocol/video-job-plan.ts +50 -0
- package/protocol/videos.ts +227 -0
- package/tsconfig.json +14 -0
- package/tunnel/ARCHITECTURE.md +111 -0
- package/tunnel/LICENSE +33 -0
- package/tunnel/README.md +45 -0
- package/tunnel/assets/openllm-light.svg +18 -0
- package/tunnel/assets/openllm.svg +18 -0
- package/tunnel/channel-envelope.ts +139 -0
- package/tunnel/codec.ts +191 -0
- package/tunnel/device-anchor.ts +229 -0
- package/tunnel/device-control.ts +118 -0
- package/tunnel/device-grant.ts +173 -0
- package/tunnel/fleet.ts +77 -0
- package/tunnel/index.ts +22 -0
- package/tunnel/mux.ts +580 -0
- package/tunnel/peer-link.ts +390 -0
- package/tunnel/rtc-auth.ts +415 -0
- package/tunnel/rtc-duplex.ts +187 -0
- package/tunnel/rtc-ice.ts +136 -0
- package/tunnel/secure.ts +1298 -0
- package/tunnel/stream-reset-error.ts +14 -0
- package/tunnel/streams.ts +1430 -0
- package/tunnel/team-grant.ts +302 -0
- package/tunnel/wire-bytes.ts +102 -0
- package/vault/ARCHITECTURE.md +470 -0
- package/vault/LICENSE +33 -0
- package/vault/api-key.ts +190 -0
- package/vault/argon2.ts +106 -0
- package/vault/cli-auth-seal.ts +157 -0
- package/vault/cred-seal.ts +146 -0
- package/vault/credential.ts +55 -0
- package/vault/crypto.ts +210 -0
- package/vault/daemon-attest.ts +229 -0
- package/vault/derive.ts +113 -0
- package/vault/device-access.ts +87 -0
- package/vault/device-anchor.ts +185 -0
- package/vault/device-control.ts +174 -0
- package/vault/handoff.ts +396 -0
- package/vault/index.ts +21 -0
- package/vault/passkey.ts +243 -0
- package/vault/phrase.ts +65 -0
- package/vault/pin.ts +153 -0
- package/vault/public-key-seal.ts +131 -0
- package/vault/seed.ts +272 -0
- package/vault/team.ts +355 -0
- package/vault/vault-item.ts +131 -0
- package/vault/vault-migrate-digest.ts +29 -0
- package/vault/wrapped.ts +77 -0
- package/wire/ARCHITECTURE.md +90 -0
- package/wire/CONTRIBUTING.md +19 -0
- package/wire/LICENSE +33 -0
- package/wire/README.md +51 -0
- package/wire/adapters/messages/anthropic-map.ts +37 -0
- package/wire/adapters/messages/index.ts +7 -0
- package/wire/adapters/messages/reasoning-from-items.ts +38 -0
- package/wire/adapters/messages/reasoning-signature.ts +243 -0
- package/wire/adapters/messages/request.ts +574 -0
- package/wire/adapters/messages/response.ts +215 -0
- package/wire/adapters/messages/streaming.ts +1027 -0
- package/wire/adapters/messages/usage.ts +43 -0
- package/wire/adapters/responses/index.ts +3 -0
- package/wire/adapters/responses/request.ts +395 -0
- package/wire/adapters/responses/response.ts +88 -0
- package/wire/adapters/responses/streaming.ts +344 -0
- package/wire/assets/openllm-light.svg +18 -0
- package/wire/assets/openllm.svg +18 -0
- package/wire/features/account-rank.ts +166 -0
- package/wire/features/compaction/compact-request.ts +862 -0
- package/wire/features/compaction/compaction-text.ts +43 -0
- package/wire/features/context-demote.ts +47 -0
- package/wire/features/context-overflow-strategy.ts +26 -0
- package/wire/features/context-skip.ts +170 -0
- package/wire/features/conversation-affinity.ts +144 -0
- package/wire/features/max-tokens-backfill.ts +141 -0
- package/wire/features/model-caps.ts +53 -0
- package/wire/features/model-settings.ts +24 -0
- package/wire/features/output-limit-clamp.ts +64 -0
- package/wire/features/quota-gate.ts +85 -0
- package/wire/index.ts +44 -0
- package/wire/lib/attempt-outcome.ts +43 -0
- package/wire/lib/canonical/content-part.ts +38 -0
- package/wire/lib/canonical/count-tokens-capability.ts +138 -0
- package/wire/lib/canonical/encoding-select.ts +82 -0
- package/wire/lib/canonical/image-signature.ts +202 -0
- package/wire/lib/canonical/image-sse.ts +216 -0
- package/wire/lib/canonical/message.ts +43 -0
- package/wire/lib/canonical/token-estimate.ts +266 -0
- package/wire/lib/encrypted-content.ts +66 -0
- package/wire/lib/error-class.ts +154 -0
- package/wire/lib/error-envelope.ts +56 -0
- package/wire/lib/forwarded-headers.ts +180 -0
- package/wire/lib/provider-error-rules.ts +48 -0
- package/wire/lib/refusal.ts +38 -0
- package/wire/lib/responses-apply-patch.ts +104 -0
- package/wire/lib/responses-namespace.ts +53 -0
- package/wire/lib/secret-scrub.ts +101 -0
- package/wire/lib/streaming/accumulate.ts +221 -0
- package/wire/lib/streaming/finish-reason.ts +33 -0
- package/wire/lib/streaming/peek.ts +154 -0
- package/wire/lib/streaming/provider-decode.ts +259 -0
- package/wire/lib/streaming/response-stream.ts +71 -0
- package/wire/lib/streaming/sse.ts +699 -0
- package/wire/lib/streaming/strip-tool-calls.ts +95 -0
- package/wire/lib/streaming/upstream-error.ts +58 -0
- package/wire/lib/strip-subagent-isolation.ts +284 -0
- package/wire/lib/thinking-signature.ts +156 -0
- package/wire/lib/token-ruler/bpe-core.ts +426 -0
- package/wire/lib/token-ruler/index.ts +2 -0
- package/wire/lib/token-ruler/ruler.ts +79 -0
- package/wire/lib/token-ruler/vocab/claude-ranks.ts +16 -0
- package/wire/lib/token-ruler/vocab/claude.ts +22 -0
- package/wire/lib/token-ruler/vocab/o200k-ranks.ts +18 -0
- package/wire/lib/token-ruler/vocab/o200k.ts +19 -0
- package/wire/lib/tool-name-map.ts +271 -0
- package/wire/lib/tool-schema.ts +353 -0
- package/wire/lib/usage-observer.ts +125 -0
- package/wire/providers/anthropic/adaptive-thinking.ts +291 -0
- package/wire/providers/anthropic/beta-headers.ts +165 -0
- package/wire/providers/anthropic/index.ts +10 -0
- package/wire/providers/anthropic/request.ts +607 -0
- package/wire/providers/anthropic/response.ts +155 -0
- package/wire/providers/anthropic/streaming.ts +315 -0
- package/wire/providers/anthropic/web-search-domains.ts +49 -0
- package/wire/providers/chatgpt/common.ts +136 -0
- package/wire/providers/chatgpt/index.ts +9 -0
- package/wire/providers/chatgpt/request.ts +959 -0
- package/wire/providers/chatgpt/streaming.ts +1007 -0
- package/wire/providers/chatgpt/web-search.ts +63 -0
- package/wire/providers/grok/web-search.ts +87 -0
- package/wire/providers/kimi/web-search.ts +145 -0
- package/wire/providers/upstream-deny.ts +355 -0
- package/wire/providers/upstream-request.ts +619 -0
|
@@ -0,0 +1,947 @@
|
|
|
1
|
+
import { Schema as S } from "effect";
|
|
2
|
+
import type * as Result from "effect/Result";
|
|
3
|
+
import type { SchemaError } from "effect/Schema";
|
|
4
|
+
import type { TAuthLoginFailedCode } from "./auth";
|
|
5
|
+
import { AuthLoginFailedCode } from "./auth";
|
|
6
|
+
import type {
|
|
7
|
+
TDaemonProviderObservation,
|
|
8
|
+
TDaemonProviderReasonCode,
|
|
9
|
+
} from "./provider-status";
|
|
10
|
+
import {
|
|
11
|
+
DaemonProviderObservation,
|
|
12
|
+
DaemonProviderReasonCode,
|
|
13
|
+
} from "./provider-status";
|
|
14
|
+
import { ReplaySessionId } from "./replay-session";
|
|
15
|
+
import { sha256Hex } from "./sha256-hex";
|
|
16
|
+
import type { TSubscriptionProviderSlug } from "./subscription-provider";
|
|
17
|
+
import { SubscriptionProviderSlug } from "./subscription-provider";
|
|
18
|
+
|
|
19
|
+
/**
|
|
20
|
+
* Incremental daemon doctor-report wire contract.
|
|
21
|
+
*
|
|
22
|
+
* Closed allowlists only — never a free-form `properties`/`meta` map, never
|
|
23
|
+
* raw log text, stacks, argv, credentials, account hashes, hostnames, or
|
|
24
|
+
* prompt/completion content. Unknown keys and unknown schema versions fail
|
|
25
|
+
* decode. Per-event `daemon_version` is stamped at observation time and is
|
|
26
|
+
* immutable on the wire.
|
|
27
|
+
*/
|
|
28
|
+
|
|
29
|
+
export const DOCTOR_REPORT_SCHEMA_VERSION = 3 as const;
|
|
30
|
+
|
|
31
|
+
export const DoctorReportSchemaVersion = S.Literals([
|
|
32
|
+
DOCTOR_REPORT_SCHEMA_VERSION,
|
|
33
|
+
]);
|
|
34
|
+
export type TDoctorReportSchemaVersion = S.Schema.Type<
|
|
35
|
+
typeof DoctorReportSchemaVersion
|
|
36
|
+
>;
|
|
37
|
+
|
|
38
|
+
export const STRICT_DOCTOR_PARSE = {
|
|
39
|
+
errors: "all",
|
|
40
|
+
onExcessProperty: "error",
|
|
41
|
+
} as const;
|
|
42
|
+
|
|
43
|
+
/** UUID or 16–64 lowercase hex. Rejects `sk-llm-`, URLs, and prefixed labels. */
|
|
44
|
+
export const DOCTOR_OPAQUE_ID_PATTERN =
|
|
45
|
+
/^(?:[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}|[0-9a-f]{16,64})$/;
|
|
46
|
+
|
|
47
|
+
export const OpaqueId = S.String.check(S.isPattern(DOCTOR_OPAQUE_ID_PATTERN));
|
|
48
|
+
export type TOpaqueId = S.Schema.Type<typeof OpaqueId>;
|
|
49
|
+
|
|
50
|
+
export const DOCTOR_SCOPE_HASH_PREFIX = "openllm-doctor-scope-v1" as const;
|
|
51
|
+
export const DoctorScopeLabel = S.Literals(["origin", "account"]);
|
|
52
|
+
export type TDoctorScopeLabel = S.Schema.Type<typeof DoctorScopeLabel>;
|
|
53
|
+
|
|
54
|
+
/** Opaque origin/account scope: sha256 hex truncated to 32 chars. */
|
|
55
|
+
export const doctorReportingScopeId = (
|
|
56
|
+
label: TDoctorScopeLabel,
|
|
57
|
+
value: string,
|
|
58
|
+
): TOpaqueId => {
|
|
59
|
+
const digest = sha256Hex(
|
|
60
|
+
`${DOCTOR_SCOPE_HASH_PREFIX}:${label}:${value}`,
|
|
61
|
+
).slice(0, 32);
|
|
62
|
+
return S.decodeUnknownSync(OpaqueId)(digest, STRICT_DOCTOR_PARSE);
|
|
63
|
+
};
|
|
64
|
+
|
|
65
|
+
export const opaqueDoctorScope = doctorReportingScopeId;
|
|
66
|
+
|
|
67
|
+
/** Bare semver, optional prerelease (`2.6.25`, `2.6.25-dev`). No leading `v`. */
|
|
68
|
+
export const DOCTOR_VERSION_STAMP_PATTERN =
|
|
69
|
+
/^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-[0-9A-Za-z.-]{1,32})?$/;
|
|
70
|
+
|
|
71
|
+
export const VersionStamp = S.String.check(
|
|
72
|
+
S.isMaxLength(64),
|
|
73
|
+
S.isPattern(DOCTOR_VERSION_STAMP_PATTERN),
|
|
74
|
+
);
|
|
75
|
+
export type TVersionStamp = S.Schema.Type<typeof VersionStamp>;
|
|
76
|
+
|
|
77
|
+
export const DOCTOR_EPOCH_MS_MAX = 4_102_444_800_000;
|
|
78
|
+
|
|
79
|
+
export const EpochMs = S.Number.check(
|
|
80
|
+
S.isFinite(),
|
|
81
|
+
S.isInt(),
|
|
82
|
+
S.isGreaterThanOrEqualTo(0),
|
|
83
|
+
S.isLessThanOrEqualTo(DOCTOR_EPOCH_MS_MAX),
|
|
84
|
+
);
|
|
85
|
+
const FiniteMs = S.Number.check(
|
|
86
|
+
S.isFinite(),
|
|
87
|
+
S.isGreaterThanOrEqualTo(0),
|
|
88
|
+
S.isLessThanOrEqualTo(86_400_000),
|
|
89
|
+
);
|
|
90
|
+
const FiniteCount = S.Number.check(
|
|
91
|
+
S.isFinite(),
|
|
92
|
+
S.isInt(),
|
|
93
|
+
S.isGreaterThanOrEqualTo(0),
|
|
94
|
+
S.isLessThanOrEqualTo(1_000_000),
|
|
95
|
+
);
|
|
96
|
+
const BoundedExitCode = S.Number.check(
|
|
97
|
+
S.isFinite(),
|
|
98
|
+
S.isInt(),
|
|
99
|
+
S.isGreaterThanOrEqualTo(-1),
|
|
100
|
+
S.isLessThanOrEqualTo(255),
|
|
101
|
+
);
|
|
102
|
+
|
|
103
|
+
export const DoctorPlatform = S.Literals(["darwin", "linux", "win32"]);
|
|
104
|
+
export type TDoctorPlatform = S.Schema.Type<typeof DoctorPlatform>;
|
|
105
|
+
|
|
106
|
+
export const DoctorArchitecture = S.Literals(["arm64", "x64"]);
|
|
107
|
+
export type TDoctorArchitecture = S.Schema.Type<typeof DoctorArchitecture>;
|
|
108
|
+
|
|
109
|
+
export const DoctorSeverity = S.Literals(["info", "warn", "error"]);
|
|
110
|
+
export type TDoctorSeverity = S.Schema.Type<typeof DoctorSeverity>;
|
|
111
|
+
|
|
112
|
+
export const DOCTOR_SCOPE_FALLBACK = "daemon" as const;
|
|
113
|
+
|
|
114
|
+
/** Allowlisted finite timings/counts/booleans. All optional; absent ≠ zero. */
|
|
115
|
+
export const DoctorEventTimings = S.Struct({
|
|
116
|
+
configured_timeout_ms: S.optional(FiniteMs),
|
|
117
|
+
/** Per-request tunnel channel-open latency. */
|
|
118
|
+
open_ms: S.optional(FiniteMs),
|
|
119
|
+
/** Per-request tunnel serving admission latency. */
|
|
120
|
+
admission_ms: S.optional(FiniteMs),
|
|
121
|
+
/** Per-request tunnel time to response head. */
|
|
122
|
+
res_head_ms: S.optional(FiniteMs),
|
|
123
|
+
spawn_elapsed_ms: S.optional(FiniteMs),
|
|
124
|
+
budget_remaining_ms_at_spawn: S.optional(FiniteMs),
|
|
125
|
+
timeout_callback_lateness_ms: S.optional(FiniteMs),
|
|
126
|
+
cleanup_ms: S.optional(FiniteMs),
|
|
127
|
+
elapsed_ms: S.optional(FiniteMs),
|
|
128
|
+
reconnect_episode_ms: S.optional(FiniteMs),
|
|
129
|
+
reconnect_count: S.optional(FiniteCount),
|
|
130
|
+
unknown_probe_streak: S.optional(FiniteCount),
|
|
131
|
+
repeat_count: S.optional(FiniteCount),
|
|
132
|
+
root_exit_code: S.optional(BoundedExitCode),
|
|
133
|
+
stdout_closed: S.optional(S.Boolean),
|
|
134
|
+
stderr_closed: S.optional(S.Boolean),
|
|
135
|
+
root_exited: S.optional(S.Boolean),
|
|
136
|
+
/** Login-start: host CLI is a shebang script (vs native binary). */
|
|
137
|
+
cli_is_script: S.optional(S.Boolean),
|
|
138
|
+
/** Login-start: shebang interpreter resolves on the daemon spawn PATH. */
|
|
139
|
+
interpreter_resolved: S.optional(S.Boolean),
|
|
140
|
+
/**
|
|
141
|
+
* Privacy-safe: resolved launcher sits under a known manager install/shim
|
|
142
|
+
* root (mise/asdf/volta/proto). Never a raw path.
|
|
143
|
+
*/
|
|
144
|
+
launcher_under_manager_root: S.optional(S.Boolean),
|
|
145
|
+
});
|
|
146
|
+
export type TDoctorEventTimings = S.Schema.Type<typeof DoctorEventTimings>;
|
|
147
|
+
|
|
148
|
+
/** Closed launcher-kind vocabulary for doctor (no raw paths). */
|
|
149
|
+
export const DoctorLauncherKind = S.Literals([
|
|
150
|
+
"binary",
|
|
151
|
+
"script",
|
|
152
|
+
"shim",
|
|
153
|
+
"wrapper",
|
|
154
|
+
]);
|
|
155
|
+
export type TDoctorLauncherKind = S.Schema.Type<typeof DoctorLauncherKind>;
|
|
156
|
+
|
|
157
|
+
/**
|
|
158
|
+
* Closed adapter ids we may attribute a shim resolution to. Single source
|
|
159
|
+
* for doctor + daemon manager adapters — consumers must reference this
|
|
160
|
+
* const (not re-list the four ids). NOTE for manager-resolution /
|
|
161
|
+
* launcher-roots owners: derive shim adapter ids from
|
|
162
|
+
* {@link DOCTOR_LAUNCHER_ADAPTERS} so doctor + spawn PATH cannot drift.
|
|
163
|
+
*/
|
|
164
|
+
export const DOCTOR_LAUNCHER_ADAPTERS = [
|
|
165
|
+
"mise",
|
|
166
|
+
"asdf",
|
|
167
|
+
"volta",
|
|
168
|
+
"proto",
|
|
169
|
+
] as const;
|
|
170
|
+
export const DoctorLauncherAdapter = S.Literals(DOCTOR_LAUNCHER_ADAPTERS);
|
|
171
|
+
export type TDoctorLauncherAdapter = (typeof DOCTOR_LAUNCHER_ADAPTERS)[number];
|
|
172
|
+
|
|
173
|
+
export const DoctorCachedHealth = S.Struct({
|
|
174
|
+
connected_providers: FiniteCount,
|
|
175
|
+
degraded_providers: FiniteCount,
|
|
176
|
+
unknown_providers: FiniteCount,
|
|
177
|
+
});
|
|
178
|
+
export type TDoctorCachedHealth = S.Schema.Type<typeof DoctorCachedHealth>;
|
|
179
|
+
|
|
180
|
+
/**
|
|
181
|
+
* Closed auth-lifecycle ledger. Optional on schema 3 so a report that omits
|
|
182
|
+
* them still parses. A *strict* schema-3 origin that does not yet list these
|
|
183
|
+
* keys still rejects them (`onExcessProperty: error`) — uploaders must strip
|
|
184
|
+
* on 422 rather than treating keep-v3 as fully backward compatible.
|
|
185
|
+
*/
|
|
186
|
+
export const DoctorAuthOperationKind = S.Literals([
|
|
187
|
+
"login",
|
|
188
|
+
"logout",
|
|
189
|
+
"verify",
|
|
190
|
+
"status_probe",
|
|
191
|
+
"status_publish",
|
|
192
|
+
]);
|
|
193
|
+
export type TDoctorAuthOperationKind = S.Schema.Type<
|
|
194
|
+
typeof DoctorAuthOperationKind
|
|
195
|
+
>;
|
|
196
|
+
|
|
197
|
+
export const DoctorAuthPhase = S.Literals([
|
|
198
|
+
"readiness_wait",
|
|
199
|
+
"readiness",
|
|
200
|
+
"start",
|
|
201
|
+
"child_wait",
|
|
202
|
+
"child",
|
|
203
|
+
/** A sign-in URL/code was surfaced to the user (stream/device logins). */
|
|
204
|
+
"prompt",
|
|
205
|
+
"prep_wait",
|
|
206
|
+
"prep",
|
|
207
|
+
"verify_wait",
|
|
208
|
+
"verify",
|
|
209
|
+
"terminal",
|
|
210
|
+
]);
|
|
211
|
+
export type TDoctorAuthPhase = S.Schema.Type<typeof DoctorAuthPhase>;
|
|
212
|
+
|
|
213
|
+
export const DoctorAuthOutcome = S.Literals([
|
|
214
|
+
"succeeded",
|
|
215
|
+
"failed",
|
|
216
|
+
"cancelled",
|
|
217
|
+
"abandoned",
|
|
218
|
+
"timeout",
|
|
219
|
+
"unknown",
|
|
220
|
+
]);
|
|
221
|
+
export type TDoctorAuthOutcome = S.Schema.Type<typeof DoctorAuthOutcome>;
|
|
222
|
+
|
|
223
|
+
/**
|
|
224
|
+
* How a browser-applied live status snapshot relates to an auth terminal.
|
|
225
|
+
* `temporal_same_session` is not causal: the snapshot was applied on the same
|
|
226
|
+
* live daemon session after the operation's seq floor, with this flow no
|
|
227
|
+
* longer on `pending_auth`. Status may precede the terminal frame.
|
|
228
|
+
*/
|
|
229
|
+
export const DoctorAuthStatusCorrelation = S.Literal("temporal_same_session");
|
|
230
|
+
export type TDoctorAuthStatusCorrelation = S.Schema.Type<
|
|
231
|
+
typeof DoctorAuthStatusCorrelation
|
|
232
|
+
>;
|
|
233
|
+
|
|
234
|
+
const DoctorStatusSeq = S.Number.check(
|
|
235
|
+
S.isFinite(),
|
|
236
|
+
S.isInt(),
|
|
237
|
+
S.isGreaterThanOrEqualTo(0),
|
|
238
|
+
S.isLessThanOrEqualTo(1_000_000_000),
|
|
239
|
+
);
|
|
240
|
+
|
|
241
|
+
/**
|
|
242
|
+
* Closed credential-store operation ledger. Optional on schema 3; strict old
|
|
243
|
+
* origins reject these keys (`onExcessProperty: error`) so uploaders strip on
|
|
244
|
+
* 422 alongside the auth outcome ledger. Never raw stderr/path/meta.
|
|
245
|
+
*/
|
|
246
|
+
export const DoctorStoreOperation = S.Literals([
|
|
247
|
+
"create",
|
|
248
|
+
"settings",
|
|
249
|
+
"unlock",
|
|
250
|
+
"install",
|
|
251
|
+
"restore",
|
|
252
|
+
"grant",
|
|
253
|
+
"recreate",
|
|
254
|
+
]);
|
|
255
|
+
export type TDoctorStoreOperation = S.Schema.Type<typeof DoctorStoreOperation>;
|
|
256
|
+
|
|
257
|
+
export const DoctorStoreStage = S.Literals(["staging", "final", "recovery"]);
|
|
258
|
+
export type TDoctorStoreStage = S.Schema.Type<typeof DoctorStoreStage>;
|
|
259
|
+
|
|
260
|
+
export const DoctorStoreResult = S.Literals([
|
|
261
|
+
"succeeded",
|
|
262
|
+
"failed",
|
|
263
|
+
"timed_out",
|
|
264
|
+
"aborted",
|
|
265
|
+
"peer_won",
|
|
266
|
+
"skipped",
|
|
267
|
+
]);
|
|
268
|
+
export type TDoctorStoreResult = S.Schema.Type<typeof DoctorStoreResult>;
|
|
269
|
+
|
|
270
|
+
/** macOS product version (`27.0.1`) / build (`26A434`), read from
|
|
271
|
+
* SystemVersion.plist. Platform facts only — same sensitivity as `platform`. */
|
|
272
|
+
export const DoctorOsVersion = S.String.check(
|
|
273
|
+
S.isPattern(/^\d{1,3}(?:\.\d{1,3}){0,2}$/),
|
|
274
|
+
);
|
|
275
|
+
export const DoctorOsBuild = S.String.check(S.isPattern(/^[0-9A-Za-z]{1,16}$/));
|
|
276
|
+
|
|
277
|
+
export const DoctorStoreExitCode = S.Number.check(
|
|
278
|
+
S.isFinite(),
|
|
279
|
+
S.isInt(),
|
|
280
|
+
S.isGreaterThanOrEqualTo(0),
|
|
281
|
+
S.isLessThanOrEqualTo(255),
|
|
282
|
+
);
|
|
283
|
+
export type TDoctorStoreExitCode = S.Schema.Type<typeof DoctorStoreExitCode>;
|
|
284
|
+
|
|
285
|
+
/** Mapped from local classifier tokens (`-25293`, `-25295`, passphrase). */
|
|
286
|
+
export const DoctorStoreClassifier = S.Literals([
|
|
287
|
+
"auth_failed",
|
|
288
|
+
"invalid_keychain",
|
|
289
|
+
"passphrase_refused",
|
|
290
|
+
]);
|
|
291
|
+
export type TDoctorStoreClassifier = S.Schema.Type<
|
|
292
|
+
typeof DoctorStoreClassifier
|
|
293
|
+
>;
|
|
294
|
+
|
|
295
|
+
/**
|
|
296
|
+
* Closed classification of a failed child process's output (vendor CLI login,
|
|
297
|
+
* version probe, version-manager resolution). Computed LOCALLY from the
|
|
298
|
+
* captured stdout/stderr by `classifyFailureOutput`; the text itself never
|
|
299
|
+
* leaves the machine. Lets a remote diagnosis separate "the sandbox denied a read
|
|
300
|
+
* of the user's mise config" and "the CLI crashed" without raw stderr.
|
|
301
|
+
*/
|
|
302
|
+
export const DoctorFailureSignature = S.Literals([
|
|
303
|
+
"mise_permission_denied",
|
|
304
|
+
"mise_error",
|
|
305
|
+
"launcher_write_denied",
|
|
306
|
+
"launcher_interpreter_missing",
|
|
307
|
+
"launcher_unresolved",
|
|
308
|
+
"permission_denied",
|
|
309
|
+
"sandbox_denied",
|
|
310
|
+
"not_found",
|
|
311
|
+
"network",
|
|
312
|
+
"manager_unresolved",
|
|
313
|
+
"no_output",
|
|
314
|
+
"unclassified",
|
|
315
|
+
]);
|
|
316
|
+
export type TDoctorFailureSignature = S.Schema.Type<
|
|
317
|
+
typeof DoctorFailureSignature
|
|
318
|
+
>;
|
|
319
|
+
|
|
320
|
+
/**
|
|
321
|
+
* Signatures a schema-3 origin that pre-dates the launcher_* mechanism
|
|
322
|
+
* classes already accepts. Used by {@link wireCompatibleFailureSignature}
|
|
323
|
+
* so a newer daemon can fall back on the wire without waiting for a cloud
|
|
324
|
+
* capability bit; local classification still uses the full vocabulary.
|
|
325
|
+
*/
|
|
326
|
+
export const DOCTOR_LEGACY_FAILURE_SIGNATURES = [
|
|
327
|
+
"mise_permission_denied",
|
|
328
|
+
"mise_error",
|
|
329
|
+
"permission_denied",
|
|
330
|
+
"sandbox_denied",
|
|
331
|
+
"not_found",
|
|
332
|
+
"network",
|
|
333
|
+
"manager_unresolved",
|
|
334
|
+
"no_output",
|
|
335
|
+
"unclassified",
|
|
336
|
+
] as const satisfies ReadonlyArray<TDoctorFailureSignature>;
|
|
337
|
+
|
|
338
|
+
export type TDoctorLegacyFailureSignature =
|
|
339
|
+
(typeof DOCTOR_LEGACY_FAILURE_SIGNATURES)[number];
|
|
340
|
+
|
|
341
|
+
/** Map a full {@link DoctorFailureSignature} onto the closest legacy value
|
|
342
|
+
* an older strict origin will accept on the wire. Identity for already-
|
|
343
|
+
* legacy signatures. */
|
|
344
|
+
export const wireCompatibleFailureSignature = (
|
|
345
|
+
signature: TDoctorFailureSignature,
|
|
346
|
+
): TDoctorLegacyFailureSignature => {
|
|
347
|
+
switch (signature) {
|
|
348
|
+
case "launcher_write_denied":
|
|
349
|
+
return "permission_denied";
|
|
350
|
+
case "launcher_interpreter_missing":
|
|
351
|
+
return "not_found";
|
|
352
|
+
case "launcher_unresolved":
|
|
353
|
+
return "manager_unresolved";
|
|
354
|
+
default:
|
|
355
|
+
return signature;
|
|
356
|
+
}
|
|
357
|
+
};
|
|
358
|
+
|
|
359
|
+
/** Map captured child output onto a {@link DoctorFailureSignature}. Pure;
|
|
360
|
+
* order matters (most specific first). Manager-specific `mise_*` signatures
|
|
361
|
+
* keep precedence over the generic `launcher_*` mechanism classes. */
|
|
362
|
+
export const classifyFailureOutput = (
|
|
363
|
+
captured: string,
|
|
364
|
+
): TDoctorFailureSignature => {
|
|
365
|
+
const text = captured.toLowerCase();
|
|
366
|
+
if (text.trim().length === 0) return "no_output";
|
|
367
|
+
const denied = /permission denied|os error 13|eacces/.test(text);
|
|
368
|
+
if (/\bmise\b/.test(text)) {
|
|
369
|
+
return denied ? "mise_permission_denied" : "mise_error";
|
|
370
|
+
}
|
|
371
|
+
// `env: node: No such file or directory` / `/usr/bin/env: 'python3': ...`
|
|
372
|
+
// / prefixed `login failed: env: node: …` / nix `…/bin/env:` — shebang
|
|
373
|
+
// interpreter missing on the spawn PATH (npm globals, etc.).
|
|
374
|
+
// Require the `: no such file` clause so a CLI status line like
|
|
375
|
+
// `env: production` is not misclassified. Loosen the start anchor so
|
|
376
|
+
// `/bin/env:` and any `…/env:` path prefix still match.
|
|
377
|
+
if (/(?:^|[\s/])env:\s*['"]?[\w.+-]+['"]?:\s*no such file/.test(text)) {
|
|
378
|
+
return "launcher_interpreter_missing";
|
|
379
|
+
}
|
|
380
|
+
// Write denied by confinement / read-only FS — generic across launchers.
|
|
381
|
+
// Require a write verb (word-bounded). Bare `open '/path'` stays
|
|
382
|
+
// `permission_denied` — `open` alone is not proof of a write
|
|
383
|
+
// (CodeRabbit 4341596192). Avoid bare `writ` — it matched
|
|
384
|
+
// `written`/`writable`.
|
|
385
|
+
const writeVerb =
|
|
386
|
+
/\b(?:write|writes|writing|wrote|create|creates|creating|created|truncate|truncating|truncated|mkdir|unlink|rename|renames|renaming|renamed)\b/.test(
|
|
387
|
+
text,
|
|
388
|
+
);
|
|
389
|
+
if (
|
|
390
|
+
/erofs|read-only file system/.test(text) ||
|
|
391
|
+
(denied && writeVerb) ||
|
|
392
|
+
(/eperm|operation not permitted/.test(text) && writeVerb)
|
|
393
|
+
) {
|
|
394
|
+
return "launcher_write_denied";
|
|
395
|
+
}
|
|
396
|
+
// DNS / transport failures before the generic "could not resolve" launcher
|
|
397
|
+
// branch — otherwise curl's `Could not resolve host:` becomes
|
|
398
|
+
// `launcher_unresolved`. Also catch urllib3 / wget / glibc DNS phrasing
|
|
399
|
+
// (`Failed to resolve '…'`, `unable to resolve host`, `name resolution`)
|
|
400
|
+
// before the broader launcher_unresolved `failed to resolve` / `unable to
|
|
401
|
+
// resolve` match.
|
|
402
|
+
if (
|
|
403
|
+
/could not resolve host|unable to resolve host|failed to resolve '|name or service not known|name resolution|nodename nor servname|no such host|getaddrinfo|enotfound|econnrefused|econnreset|etimedout|network/.test(
|
|
404
|
+
text,
|
|
405
|
+
)
|
|
406
|
+
) {
|
|
407
|
+
return "network";
|
|
408
|
+
}
|
|
409
|
+
if (
|
|
410
|
+
/unresolved|could not resolve|failed to resolve|unable to resolve/.test(
|
|
411
|
+
text,
|
|
412
|
+
)
|
|
413
|
+
) {
|
|
414
|
+
return "launcher_unresolved";
|
|
415
|
+
}
|
|
416
|
+
if (denied) return "permission_denied";
|
|
417
|
+
if (/eperm|operation not permitted|posix_spawn/.test(text)) {
|
|
418
|
+
return "sandbox_denied";
|
|
419
|
+
}
|
|
420
|
+
if (/enoent|no such file|not found/.test(text)) return "not_found";
|
|
421
|
+
return "unclassified";
|
|
422
|
+
};
|
|
423
|
+
|
|
424
|
+
export const DOCTOR_OUTCOME_LEDGER_KEYS = [
|
|
425
|
+
"provider",
|
|
426
|
+
"operation_kind",
|
|
427
|
+
"phase",
|
|
428
|
+
"outcome",
|
|
429
|
+
"observation",
|
|
430
|
+
"reason_code",
|
|
431
|
+
"status_seq",
|
|
432
|
+
"store_operation",
|
|
433
|
+
"store_stage",
|
|
434
|
+
"store_result",
|
|
435
|
+
"store_exit_code",
|
|
436
|
+
"store_classifier",
|
|
437
|
+
"login_failure_code",
|
|
438
|
+
"failure_signature",
|
|
439
|
+
"recovery_created",
|
|
440
|
+
"recovery_unlocked",
|
|
441
|
+
"recovery_replaced",
|
|
442
|
+
"store_staging_unlocked",
|
|
443
|
+
"os_version",
|
|
444
|
+
"os_build",
|
|
445
|
+
"launcher_kind",
|
|
446
|
+
"launcher_adapter",
|
|
447
|
+
] as const;
|
|
448
|
+
|
|
449
|
+
export type TDoctorOutcomeLedger = {
|
|
450
|
+
readonly provider?: TSubscriptionProviderSlug;
|
|
451
|
+
readonly operation_kind?: TDoctorAuthOperationKind;
|
|
452
|
+
readonly phase?: TDoctorAuthPhase;
|
|
453
|
+
readonly outcome?: TDoctorAuthOutcome;
|
|
454
|
+
readonly observation?: TDaemonProviderObservation;
|
|
455
|
+
readonly reason_code?: TDaemonProviderReasonCode;
|
|
456
|
+
readonly status_seq?: number;
|
|
457
|
+
readonly store_operation?: TDoctorStoreOperation;
|
|
458
|
+
readonly store_stage?: TDoctorStoreStage;
|
|
459
|
+
readonly store_result?: TDoctorStoreResult;
|
|
460
|
+
readonly store_exit_code?: TDoctorStoreExitCode;
|
|
461
|
+
readonly store_classifier?: TDoctorStoreClassifier;
|
|
462
|
+
readonly login_failure_code?: TAuthLoginFailedCode;
|
|
463
|
+
readonly failure_signature?: TDoctorFailureSignature;
|
|
464
|
+
readonly recovery_created?: boolean;
|
|
465
|
+
readonly recovery_unlocked?: boolean;
|
|
466
|
+
readonly recovery_replaced?: boolean;
|
|
467
|
+
/** On a final-store failure: the same store unlocked under its staging
|
|
468
|
+
* name moments earlier (so the NAME, not the password, is the variable). */
|
|
469
|
+
readonly store_staging_unlocked?: boolean;
|
|
470
|
+
readonly os_version?: string;
|
|
471
|
+
readonly os_build?: string;
|
|
472
|
+
/** Privacy-safe launcher profile kind (audit L4). */
|
|
473
|
+
readonly launcher_kind?: TDoctorLauncherKind;
|
|
474
|
+
/** Privacy-safe manager adapter id when kind is shim. */
|
|
475
|
+
readonly launcher_adapter?: TDoctorLauncherAdapter;
|
|
476
|
+
};
|
|
477
|
+
|
|
478
|
+
const decodeOptionalLiteral = <A>(
|
|
479
|
+
schema: S.ConstraintDecoder<A>,
|
|
480
|
+
value: unknown,
|
|
481
|
+
): A | undefined => {
|
|
482
|
+
if (value === undefined) return undefined;
|
|
483
|
+
try {
|
|
484
|
+
return S.decodeUnknownSync(schema)(value, STRICT_DOCTOR_PARSE);
|
|
485
|
+
} catch {
|
|
486
|
+
return undefined;
|
|
487
|
+
}
|
|
488
|
+
};
|
|
489
|
+
|
|
490
|
+
/** Producer-side projection: invalid enums are omitted, the event is kept. */
|
|
491
|
+
export const projectDoctorOutcomeLedger = (
|
|
492
|
+
input: unknown,
|
|
493
|
+
): TDoctorOutcomeLedger => {
|
|
494
|
+
if (typeof input !== "object" || input === null || Array.isArray(input)) {
|
|
495
|
+
return {};
|
|
496
|
+
}
|
|
497
|
+
const raw = input as Record<string, unknown>;
|
|
498
|
+
const ledger: {
|
|
499
|
+
-readonly [K in keyof TDoctorOutcomeLedger]?: TDoctorOutcomeLedger[K];
|
|
500
|
+
} = {};
|
|
501
|
+
const provider = decodeOptionalLiteral(
|
|
502
|
+
SubscriptionProviderSlug,
|
|
503
|
+
raw.provider,
|
|
504
|
+
);
|
|
505
|
+
if (provider !== undefined) ledger.provider = provider;
|
|
506
|
+
const operation_kind = decodeOptionalLiteral(
|
|
507
|
+
DoctorAuthOperationKind,
|
|
508
|
+
raw.operation_kind,
|
|
509
|
+
);
|
|
510
|
+
if (operation_kind !== undefined) ledger.operation_kind = operation_kind;
|
|
511
|
+
const phase = decodeOptionalLiteral(DoctorAuthPhase, raw.phase);
|
|
512
|
+
if (phase !== undefined) ledger.phase = phase;
|
|
513
|
+
const outcome = decodeOptionalLiteral(DoctorAuthOutcome, raw.outcome);
|
|
514
|
+
if (outcome !== undefined) ledger.outcome = outcome;
|
|
515
|
+
const observation = decodeOptionalLiteral(
|
|
516
|
+
DaemonProviderObservation,
|
|
517
|
+
raw.observation,
|
|
518
|
+
);
|
|
519
|
+
if (observation !== undefined) ledger.observation = observation;
|
|
520
|
+
const reason_code = decodeOptionalLiteral(
|
|
521
|
+
DaemonProviderReasonCode,
|
|
522
|
+
raw.reason_code,
|
|
523
|
+
);
|
|
524
|
+
if (reason_code !== undefined) ledger.reason_code = reason_code;
|
|
525
|
+
if (raw.status_seq !== undefined) {
|
|
526
|
+
try {
|
|
527
|
+
ledger.status_seq = S.decodeUnknownSync(DoctorStatusSeq)(
|
|
528
|
+
raw.status_seq,
|
|
529
|
+
STRICT_DOCTOR_PARSE,
|
|
530
|
+
);
|
|
531
|
+
} catch {
|
|
532
|
+
/* omit */
|
|
533
|
+
}
|
|
534
|
+
}
|
|
535
|
+
const store_operation = decodeOptionalLiteral(
|
|
536
|
+
DoctorStoreOperation,
|
|
537
|
+
raw.store_operation,
|
|
538
|
+
);
|
|
539
|
+
if (store_operation !== undefined) ledger.store_operation = store_operation;
|
|
540
|
+
const store_stage = decodeOptionalLiteral(DoctorStoreStage, raw.store_stage);
|
|
541
|
+
if (store_stage !== undefined) ledger.store_stage = store_stage;
|
|
542
|
+
const store_result = decodeOptionalLiteral(
|
|
543
|
+
DoctorStoreResult,
|
|
544
|
+
raw.store_result,
|
|
545
|
+
);
|
|
546
|
+
if (store_result !== undefined) ledger.store_result = store_result;
|
|
547
|
+
if (raw.store_exit_code !== undefined) {
|
|
548
|
+
try {
|
|
549
|
+
ledger.store_exit_code = S.decodeUnknownSync(DoctorStoreExitCode)(
|
|
550
|
+
raw.store_exit_code,
|
|
551
|
+
STRICT_DOCTOR_PARSE,
|
|
552
|
+
);
|
|
553
|
+
} catch {
|
|
554
|
+
/* omit */
|
|
555
|
+
}
|
|
556
|
+
}
|
|
557
|
+
const store_classifier = decodeOptionalLiteral(
|
|
558
|
+
DoctorStoreClassifier,
|
|
559
|
+
raw.store_classifier,
|
|
560
|
+
);
|
|
561
|
+
if (store_classifier !== undefined)
|
|
562
|
+
ledger.store_classifier = store_classifier;
|
|
563
|
+
const login_failure_code = decodeOptionalLiteral(
|
|
564
|
+
AuthLoginFailedCode,
|
|
565
|
+
raw.login_failure_code,
|
|
566
|
+
);
|
|
567
|
+
if (login_failure_code !== undefined)
|
|
568
|
+
ledger.login_failure_code = login_failure_code;
|
|
569
|
+
const failure_signature = decodeOptionalLiteral(
|
|
570
|
+
DoctorFailureSignature,
|
|
571
|
+
raw.failure_signature,
|
|
572
|
+
);
|
|
573
|
+
if (failure_signature !== undefined)
|
|
574
|
+
ledger.failure_signature = failure_signature;
|
|
575
|
+
if (typeof raw.recovery_created === "boolean") {
|
|
576
|
+
ledger.recovery_created = raw.recovery_created;
|
|
577
|
+
}
|
|
578
|
+
if (typeof raw.recovery_unlocked === "boolean") {
|
|
579
|
+
ledger.recovery_unlocked = raw.recovery_unlocked;
|
|
580
|
+
}
|
|
581
|
+
if (typeof raw.recovery_replaced === "boolean") {
|
|
582
|
+
ledger.recovery_replaced = raw.recovery_replaced;
|
|
583
|
+
}
|
|
584
|
+
if (typeof raw.store_staging_unlocked === "boolean") {
|
|
585
|
+
ledger.store_staging_unlocked = raw.store_staging_unlocked;
|
|
586
|
+
}
|
|
587
|
+
const os_version = decodeOptionalLiteral(DoctorOsVersion, raw.os_version);
|
|
588
|
+
if (os_version !== undefined) ledger.os_version = os_version;
|
|
589
|
+
const os_build = decodeOptionalLiteral(DoctorOsBuild, raw.os_build);
|
|
590
|
+
if (os_build !== undefined) ledger.os_build = os_build;
|
|
591
|
+
const launcher_kind = decodeOptionalLiteral(
|
|
592
|
+
DoctorLauncherKind,
|
|
593
|
+
raw.launcher_kind,
|
|
594
|
+
);
|
|
595
|
+
if (launcher_kind !== undefined) ledger.launcher_kind = launcher_kind;
|
|
596
|
+
const launcher_adapter = decodeOptionalLiteral(
|
|
597
|
+
DoctorLauncherAdapter,
|
|
598
|
+
raw.launcher_adapter,
|
|
599
|
+
);
|
|
600
|
+
if (launcher_adapter !== undefined)
|
|
601
|
+
ledger.launcher_adapter = launcher_adapter;
|
|
602
|
+
return ledger;
|
|
603
|
+
};
|
|
604
|
+
|
|
605
|
+
export const doctorEventHasOutcomeLedger = (
|
|
606
|
+
event: TDoctorOutcomeLedger,
|
|
607
|
+
): boolean =>
|
|
608
|
+
DOCTOR_OUTCOME_LEDGER_KEYS.some((key) => event[key] !== undefined);
|
|
609
|
+
|
|
610
|
+
/**
|
|
611
|
+
* Timing keys introduced after the schema-3 baseline that a strict older
|
|
612
|
+
* origin rejects via `onExcessProperty: error`. Stripped alongside the
|
|
613
|
+
* outcome ledger on the 422 compat retry — otherwise a report that only
|
|
614
|
+
* carries `timings.launcher_under_manager_root` still fails the retry.
|
|
615
|
+
*/
|
|
616
|
+
export const DOCTOR_FORWARD_COMPAT_TIMING_KEYS = [
|
|
617
|
+
"launcher_under_manager_root",
|
|
618
|
+
] as const;
|
|
619
|
+
|
|
620
|
+
export const stripDoctorOutcomeLedger = (report: {
|
|
621
|
+
readonly events: ReadonlyArray<TDoctorReportEvent>;
|
|
622
|
+
readonly schema_version: TDoctorReportSchemaVersion;
|
|
623
|
+
readonly report_id: TOpaqueId;
|
|
624
|
+
readonly emitted_at_ms: number;
|
|
625
|
+
readonly reporter_cli_version?: TVersionStamp;
|
|
626
|
+
readonly cursor_gap_count: number;
|
|
627
|
+
readonly suppressed_event_count: number;
|
|
628
|
+
readonly health?: TDoctorCachedHealth;
|
|
629
|
+
}): TDoctorReport => {
|
|
630
|
+
const events = report.events.map((event) => {
|
|
631
|
+
const next: Record<string, unknown> = { ...event };
|
|
632
|
+
for (const key of DOCTOR_OUTCOME_LEDGER_KEYS) {
|
|
633
|
+
delete next[key];
|
|
634
|
+
}
|
|
635
|
+
if (
|
|
636
|
+
typeof next.timings === "object" &&
|
|
637
|
+
next.timings !== null &&
|
|
638
|
+
!Array.isArray(next.timings)
|
|
639
|
+
) {
|
|
640
|
+
const timings: Record<string, unknown> = {
|
|
641
|
+
...(next.timings as Record<string, unknown>),
|
|
642
|
+
};
|
|
643
|
+
for (const key of DOCTOR_FORWARD_COMPAT_TIMING_KEYS) {
|
|
644
|
+
delete timings[key];
|
|
645
|
+
}
|
|
646
|
+
if (Object.keys(timings).length === 0) delete next.timings;
|
|
647
|
+
else next.timings = timings;
|
|
648
|
+
}
|
|
649
|
+
return next as TDoctorReportEvent;
|
|
650
|
+
});
|
|
651
|
+
return {
|
|
652
|
+
schema_version: report.schema_version,
|
|
653
|
+
report_id: report.report_id,
|
|
654
|
+
emitted_at_ms: report.emitted_at_ms,
|
|
655
|
+
...(report.reporter_cli_version !== undefined
|
|
656
|
+
? { reporter_cli_version: report.reporter_cli_version }
|
|
657
|
+
: {}),
|
|
658
|
+
cursor_gap_count: report.cursor_gap_count,
|
|
659
|
+
suppressed_event_count: report.suppressed_event_count,
|
|
660
|
+
events,
|
|
661
|
+
...(report.health !== undefined ? { health: report.health } : {}),
|
|
662
|
+
};
|
|
663
|
+
};
|
|
664
|
+
|
|
665
|
+
const BuildRevision = S.String.check(S.isPattern(/^[0-9a-f]{7,64}$/));
|
|
666
|
+
|
|
667
|
+
/** Closed, content-free tunnel request diagnostic dimensions. */
|
|
668
|
+
export const TunnelRequestPath = S.Literals([
|
|
669
|
+
"fleet",
|
|
670
|
+
"browser",
|
|
671
|
+
"origin",
|
|
672
|
+
"team",
|
|
673
|
+
]);
|
|
674
|
+
export type TTunnelRequestPath = S.Schema.Type<typeof TunnelRequestPath>;
|
|
675
|
+
|
|
676
|
+
export const TunnelRequestTransport = S.Literals(["rtc", "mux"]);
|
|
677
|
+
export type TTunnelRequestTransport = S.Schema.Type<
|
|
678
|
+
typeof TunnelRequestTransport
|
|
679
|
+
>;
|
|
680
|
+
|
|
681
|
+
export const TunnelRequestFallbackReason = S.Literals([
|
|
682
|
+
"none",
|
|
683
|
+
"rtc_failed",
|
|
684
|
+
"rtc_unavailable",
|
|
685
|
+
"mux_unavailable",
|
|
686
|
+
"channel_open_failed",
|
|
687
|
+
]);
|
|
688
|
+
export type TTunnelRequestFallbackReason = S.Schema.Type<
|
|
689
|
+
typeof TunnelRequestFallbackReason
|
|
690
|
+
>;
|
|
691
|
+
|
|
692
|
+
export const TunnelRequestPlanCache = S.Literals(["hit", "miss", "soft"]);
|
|
693
|
+
export type TTunnelRequestPlanCache = S.Schema.Type<
|
|
694
|
+
typeof TunnelRequestPlanCache
|
|
695
|
+
>;
|
|
696
|
+
|
|
697
|
+
export const DoctorReportEvent = S.Struct({
|
|
698
|
+
event_id: OpaqueId,
|
|
699
|
+
observed_at_ms: EpochMs,
|
|
700
|
+
daemon_version: VersionStamp,
|
|
701
|
+
daemon_build_revision: S.optional(BuildRevision),
|
|
702
|
+
platform: DoctorPlatform,
|
|
703
|
+
architecture: DoctorArchitecture,
|
|
704
|
+
severity: DoctorSeverity,
|
|
705
|
+
scope: S.String.check(S.isMaxLength(32), S.isMinLength(1)),
|
|
706
|
+
message: S.String.check(S.isMaxLength(240), S.isMinLength(1)),
|
|
707
|
+
correlation_id: S.optional(OpaqueId),
|
|
708
|
+
replay_session_id: S.optional(ReplaySessionId),
|
|
709
|
+
timings: S.optional(DoctorEventTimings),
|
|
710
|
+
tunnel_path: S.optional(TunnelRequestPath),
|
|
711
|
+
tunnel_transport: S.optional(TunnelRequestTransport),
|
|
712
|
+
rung_fallback_reason: S.optional(TunnelRequestFallbackReason),
|
|
713
|
+
channel_reused: S.optional(S.Boolean),
|
|
714
|
+
plan_cache: S.optional(TunnelRequestPlanCache),
|
|
715
|
+
serving_inflight: S.optional(FiniteCount),
|
|
716
|
+
provider: S.optional(SubscriptionProviderSlug),
|
|
717
|
+
operation_kind: S.optional(DoctorAuthOperationKind),
|
|
718
|
+
phase: S.optional(DoctorAuthPhase),
|
|
719
|
+
outcome: S.optional(DoctorAuthOutcome),
|
|
720
|
+
observation: S.optional(DaemonProviderObservation),
|
|
721
|
+
reason_code: S.optional(DaemonProviderReasonCode),
|
|
722
|
+
status_seq: S.optional(DoctorStatusSeq),
|
|
723
|
+
store_operation: S.optional(DoctorStoreOperation),
|
|
724
|
+
store_stage: S.optional(DoctorStoreStage),
|
|
725
|
+
store_result: S.optional(DoctorStoreResult),
|
|
726
|
+
store_exit_code: S.optional(DoctorStoreExitCode),
|
|
727
|
+
store_classifier: S.optional(DoctorStoreClassifier),
|
|
728
|
+
login_failure_code: S.optional(AuthLoginFailedCode),
|
|
729
|
+
failure_signature: S.optional(DoctorFailureSignature),
|
|
730
|
+
recovery_created: S.optional(S.Boolean),
|
|
731
|
+
recovery_unlocked: S.optional(S.Boolean),
|
|
732
|
+
recovery_replaced: S.optional(S.Boolean),
|
|
733
|
+
store_staging_unlocked: S.optional(S.Boolean),
|
|
734
|
+
os_version: S.optional(DoctorOsVersion),
|
|
735
|
+
os_build: S.optional(DoctorOsBuild),
|
|
736
|
+
launcher_kind: S.optional(DoctorLauncherKind),
|
|
737
|
+
launcher_adapter: S.optional(DoctorLauncherAdapter),
|
|
738
|
+
});
|
|
739
|
+
export type TDoctorReportEvent = S.Schema.Type<typeof DoctorReportEvent>;
|
|
740
|
+
|
|
741
|
+
export const DOCTOR_REPORT_MAX_EVENTS = 32;
|
|
742
|
+
|
|
743
|
+
export const DoctorReport = S.Struct({
|
|
744
|
+
schema_version: DoctorReportSchemaVersion,
|
|
745
|
+
report_id: OpaqueId,
|
|
746
|
+
emitted_at_ms: EpochMs,
|
|
747
|
+
reporter_cli_version: S.optional(VersionStamp),
|
|
748
|
+
cursor_gap_count: FiniteCount,
|
|
749
|
+
suppressed_event_count: FiniteCount,
|
|
750
|
+
events: S.Array(DoctorReportEvent).check(
|
|
751
|
+
S.isMinLength(1),
|
|
752
|
+
S.isMaxLength(DOCTOR_REPORT_MAX_EVENTS),
|
|
753
|
+
),
|
|
754
|
+
health: S.optional(DoctorCachedHealth),
|
|
755
|
+
});
|
|
756
|
+
export type TDoctorReport = S.Schema.Type<typeof DoctorReport>;
|
|
757
|
+
|
|
758
|
+
export const DoctorReportAck = S.Struct({
|
|
759
|
+
report_id: OpaqueId,
|
|
760
|
+
accepted_event_ids: S.Array(OpaqueId).check(
|
|
761
|
+
S.isMinLength(1),
|
|
762
|
+
S.isMaxLength(DOCTOR_REPORT_MAX_EVENTS),
|
|
763
|
+
),
|
|
764
|
+
});
|
|
765
|
+
export type TDoctorReportAck = S.Schema.Type<typeof DoctorReportAck>;
|
|
766
|
+
|
|
767
|
+
export const DoctorReportRejectCode = S.Literals([
|
|
768
|
+
"diagnostics_disabled",
|
|
769
|
+
"unauthorized",
|
|
770
|
+
"invalid",
|
|
771
|
+
"oversize",
|
|
772
|
+
"rate_limited",
|
|
773
|
+
"unavailable",
|
|
774
|
+
]);
|
|
775
|
+
export type TDoctorReportRejectCode = S.Schema.Type<
|
|
776
|
+
typeof DoctorReportRejectCode
|
|
777
|
+
>;
|
|
778
|
+
|
|
779
|
+
export const DoctorReportReject = S.Struct({
|
|
780
|
+
code: DoctorReportRejectCode,
|
|
781
|
+
report_id: S.optional(OpaqueId),
|
|
782
|
+
});
|
|
783
|
+
export type TDoctorReportReject = S.Schema.Type<typeof DoctorReportReject>;
|
|
784
|
+
|
|
785
|
+
const doctorMessageFallback = (severity: TDoctorSeverity): string => {
|
|
786
|
+
if (severity === "error") return "Daemon error.";
|
|
787
|
+
if (severity === "warn") return "Daemon warning.";
|
|
788
|
+
return "Daemon notice.";
|
|
789
|
+
};
|
|
790
|
+
|
|
791
|
+
/** Defense in depth for log scope. No catalog — invalid values fall back. */
|
|
792
|
+
export const sanitizeDoctorScope = (scope: unknown): string => {
|
|
793
|
+
if (typeof scope !== "string" || scope.length === 0 || scope.length > 32) {
|
|
794
|
+
return DOCTOR_SCOPE_FALLBACK;
|
|
795
|
+
}
|
|
796
|
+
if (!/^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$/.test(scope)) {
|
|
797
|
+
return DOCTOR_SCOPE_FALLBACK;
|
|
798
|
+
}
|
|
799
|
+
if (
|
|
800
|
+
/\b(?:password|secret|token|bearer|cookie|authorization|credential)\b/i.test(
|
|
801
|
+
scope,
|
|
802
|
+
)
|
|
803
|
+
) {
|
|
804
|
+
return DOCTOR_SCOPE_FALLBACK;
|
|
805
|
+
}
|
|
806
|
+
return scope;
|
|
807
|
+
};
|
|
808
|
+
|
|
809
|
+
/** Defense in depth for wire messages, not a grant of trust to runtime prose. */
|
|
810
|
+
export const sanitizeDoctorMessage = (
|
|
811
|
+
message: unknown,
|
|
812
|
+
severity: TDoctorSeverity,
|
|
813
|
+
): string => {
|
|
814
|
+
const fallback = doctorMessageFallback(severity);
|
|
815
|
+
if (
|
|
816
|
+
typeof message !== "string" ||
|
|
817
|
+
message.length === 0 ||
|
|
818
|
+
message.length > 240
|
|
819
|
+
)
|
|
820
|
+
return fallback;
|
|
821
|
+
if (!/^[A-Za-z][A-Za-z :;_,.'!?()-]*$/.test(message)) return fallback;
|
|
822
|
+
if (/\b[A-Za-z_-]+\.[A-Za-z]{2,}\b/.test(message)) return fallback;
|
|
823
|
+
if (
|
|
824
|
+
/\b(?:password|secret|token|bearer|cookie|authorization|credential value|login code|device code)\b/i.test(
|
|
825
|
+
message,
|
|
826
|
+
)
|
|
827
|
+
)
|
|
828
|
+
return fallback;
|
|
829
|
+
if (message.split(/[^A-Za-z]+/).some((word) => word.length > 24))
|
|
830
|
+
return fallback;
|
|
831
|
+
return message;
|
|
832
|
+
};
|
|
833
|
+
|
|
834
|
+
export const projectDoctorTimings = (
|
|
835
|
+
input: unknown,
|
|
836
|
+
): TDoctorEventTimings | undefined => {
|
|
837
|
+
if (typeof input !== "object" || input === null || Array.isArray(input))
|
|
838
|
+
return undefined;
|
|
839
|
+
const result: Record<string, number | boolean> = {};
|
|
840
|
+
for (const key of Object.keys(DoctorEventTimings.fields)) {
|
|
841
|
+
try {
|
|
842
|
+
const value = (input as Record<string, unknown>)[key];
|
|
843
|
+
if (value === undefined) continue;
|
|
844
|
+
const decoded = S.decodeUnknownSync(DoctorEventTimings)(
|
|
845
|
+
{ [key]: value },
|
|
846
|
+
STRICT_DOCTOR_PARSE,
|
|
847
|
+
);
|
|
848
|
+
Object.assign(result, decoded);
|
|
849
|
+
} catch {
|
|
850
|
+
/* Optional measurement failure must not remove an incident. */
|
|
851
|
+
}
|
|
852
|
+
}
|
|
853
|
+
return Object.keys(result).length > 0 ? result : undefined;
|
|
854
|
+
};
|
|
855
|
+
|
|
856
|
+
/**
|
|
857
|
+
* Normalize only optional measurements and message text. Excess keys still
|
|
858
|
+
* fail under {@link STRICT_DOCTOR_PARSE} (fail-closed). Launcher wire compat
|
|
859
|
+
* is narrow: the schema lists launcher_kind / launcher_adapter /
|
|
860
|
+
* timings.launcher_under_manager_root and the three launcher_* signatures
|
|
861
|
+
* explicitly; daemons map unknown-to-legacy signatures on the wire and the
|
|
862
|
+
* 422 retry strips those launcher fields via {@link stripDoctorOutcomeLedger}.
|
|
863
|
+
*/
|
|
864
|
+
const prepareEvent = (input: unknown): unknown => {
|
|
865
|
+
if (typeof input !== "object" || input === null || Array.isArray(input))
|
|
866
|
+
return input;
|
|
867
|
+
const event = input as Record<string, unknown>;
|
|
868
|
+
const next = { ...event };
|
|
869
|
+
if (
|
|
870
|
+
(event.severity === "info" ||
|
|
871
|
+
event.severity === "warn" ||
|
|
872
|
+
event.severity === "error") &&
|
|
873
|
+
typeof event.message === "string"
|
|
874
|
+
) {
|
|
875
|
+
next.message = sanitizeDoctorMessage(event.message, event.severity);
|
|
876
|
+
}
|
|
877
|
+
if (Object.hasOwn(event, "scope")) {
|
|
878
|
+
next.scope = sanitizeDoctorScope(event.scope);
|
|
879
|
+
}
|
|
880
|
+
if (
|
|
881
|
+
typeof event.timings === "object" &&
|
|
882
|
+
event.timings !== null &&
|
|
883
|
+
!Array.isArray(event.timings)
|
|
884
|
+
) {
|
|
885
|
+
// Keep excess keys for strict validation, but drop malformed known values individually.
|
|
886
|
+
const extras = Object.fromEntries(
|
|
887
|
+
Object.entries(event.timings).filter(
|
|
888
|
+
([key]) => !Object.hasOwn(DoctorEventTimings.fields, key),
|
|
889
|
+
),
|
|
890
|
+
);
|
|
891
|
+
next.timings = { ...extras, ...projectDoctorTimings(event.timings) };
|
|
892
|
+
} else if (event.timings !== undefined) {
|
|
893
|
+
delete next.timings;
|
|
894
|
+
}
|
|
895
|
+
if (
|
|
896
|
+
event.correlation_id !== undefined &&
|
|
897
|
+
!S.is(OpaqueId)(event.correlation_id)
|
|
898
|
+
)
|
|
899
|
+
delete next.correlation_id;
|
|
900
|
+
if (
|
|
901
|
+
event.daemon_build_revision !== undefined &&
|
|
902
|
+
!S.is(BuildRevision)(event.daemon_build_revision)
|
|
903
|
+
)
|
|
904
|
+
delete next.daemon_build_revision;
|
|
905
|
+
return next;
|
|
906
|
+
};
|
|
907
|
+
const prepareReport = (input: unknown): unknown => {
|
|
908
|
+
if (typeof input !== "object" || input === null || Array.isArray(input))
|
|
909
|
+
return input;
|
|
910
|
+
const report = input as Record<string, unknown>;
|
|
911
|
+
return Array.isArray(report.events)
|
|
912
|
+
? { ...report, events: report.events.map(prepareEvent) }
|
|
913
|
+
: input;
|
|
914
|
+
};
|
|
915
|
+
export const parseDoctorReport = (input: unknown): TDoctorReport =>
|
|
916
|
+
S.decodeUnknownSync(DoctorReport)(prepareReport(input), STRICT_DOCTOR_PARSE);
|
|
917
|
+
export const parseDoctorReportEvent = (input: unknown): TDoctorReportEvent =>
|
|
918
|
+
S.decodeUnknownSync(DoctorReportEvent)(
|
|
919
|
+
prepareEvent(input),
|
|
920
|
+
STRICT_DOCTOR_PARSE,
|
|
921
|
+
);
|
|
922
|
+
|
|
923
|
+
export const parseDoctorReportAck = (input: unknown): TDoctorReportAck =>
|
|
924
|
+
S.decodeUnknownSync(DoctorReportAck)(input, STRICT_DOCTOR_PARSE);
|
|
925
|
+
|
|
926
|
+
export const parseDoctorReportReject = (input: unknown): TDoctorReportReject =>
|
|
927
|
+
S.decodeUnknownSync(DoctorReportReject)(input, STRICT_DOCTOR_PARSE);
|
|
928
|
+
|
|
929
|
+
/** Effect result success-first: `Result<A, E>` = Success<A> | Failure<E>. */
|
|
930
|
+
export type TDoctorReportDecode = Result.Result<TDoctorReport, SchemaError>;
|
|
931
|
+
export type TDoctorReportEventDecode = Result.Result<
|
|
932
|
+
TDoctorReportEvent,
|
|
933
|
+
SchemaError
|
|
934
|
+
>;
|
|
935
|
+
|
|
936
|
+
export const decodeDoctorReportResult = (input: unknown): TDoctorReportDecode =>
|
|
937
|
+
S.decodeUnknownResult(DoctorReport)(
|
|
938
|
+
prepareReport(input),
|
|
939
|
+
STRICT_DOCTOR_PARSE,
|
|
940
|
+
);
|
|
941
|
+
export const decodeDoctorReportEventResult = (
|
|
942
|
+
input: unknown,
|
|
943
|
+
): TDoctorReportEventDecode =>
|
|
944
|
+
S.decodeUnknownResult(DoctorReportEvent)(
|
|
945
|
+
prepareEvent(input),
|
|
946
|
+
STRICT_DOCTOR_PARSE,
|
|
947
|
+
);
|