@bitkyc08/opencodex 2.94.0 → 2.96.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/gui/dist/assets/App-B4j-Txmb.css +1 -0
- package/gui/dist/assets/App-bwugJRKn.js +58 -0
- package/gui/dist/assets/{Tray-CZatQdoF.js → Tray-BOPQyDbH.js} +1 -1
- package/gui/dist/assets/index-ebuVUtB7.js +94 -0
- package/gui/dist/assets/quota-summary-6HsrHQAy.js +1 -0
- package/gui/dist/index.html +1 -1
- package/package.json +1 -1
- package/src/adapters/anthropic.ts +10 -3
- package/src/adapters/command-code-project-context.ts +3 -3
- package/src/adapters/kiro/adapter.ts +4 -1
- package/src/adapters/kiro/stream.ts +1 -0
- package/src/adapters/kiro-events.ts +1 -0
- package/src/adapters/ollama-native.ts +10 -6
- package/src/adapters/openai-chat/messages.ts +20 -7
- package/src/adapters/openai-chat/passthrough.ts +4 -2
- package/src/adapters/openai-chat/single-system.ts +24 -0
- package/src/adapters/openai-responses/canonical-forward.ts +50 -13
- package/src/adapters/openai-responses/muse-tool-catalog.ts +87 -0
- package/src/adapters/openai-responses/passthrough.ts +45 -11
- package/src/adapters/openai-responses/prompt-cache.ts +3 -1
- package/src/adapters/openai-responses/request-strips.ts +23 -4
- package/src/adapters/openai-responses/tool-output-recovery.ts +21 -8
- package/src/adapters/openai-responses/tool-schema.ts +20 -8
- package/src/adapters/openai-responses/transport.ts +17 -26
- package/src/adapters/opencode-go-additional-tools.ts +39 -6
- package/src/adapters/qoder/adapter.ts +1 -1
- package/src/adapters/qoder/image-input.ts +5 -2
- package/src/adapters/routed-agent-messages.ts +3 -0
- package/src/adapters/xai-web-search.ts +6 -3
- package/src/adapters/zed-additional-tools.ts +7 -7
- package/src/adapters/zed.ts +1 -6
- package/src/advisor/consult.ts +22 -10
- package/src/advisor/runtime.ts +10 -4
- package/src/bridge/max-output-completion.ts +41 -0
- package/src/bridge/response-json.ts +9 -4
- package/src/bridge/sse.ts +13 -2
- package/src/chatgpt/app-server-shim/bundle-trust-policy.ts +5 -0
- package/src/chatgpt/app-server-shim/launcher.ts +40 -6
- package/src/claude/compatibility.ts +5 -1
- package/src/claude/desktop-3p.ts +27 -6
- package/src/claude/desktop-model-visibility.ts +141 -0
- package/src/claude/desktop-remote-store-io.ts +8 -8
- package/src/claude/inbound-content-options.ts +11 -1
- package/src/claude/intercept/proxy-auth.ts +16 -16
- package/src/cli/account-main.ts +3 -2
- package/src/cli/agent.ts +44 -15
- package/src/cli/capabilities-agents-routing.ts +9 -0
- package/src/cli/capabilities-provider-models.ts +7 -0
- package/src/cli/chatgpt-command.ts +1 -1
- package/src/cli/codex-launcher.ts +20 -8
- package/src/cli/codex-shim-autorestore.ts +19 -1
- package/src/cli/dispatch.ts +6 -6
- package/src/cli/doctor.ts +5 -5
- package/src/cli/ensure-desired-integrations.ts +4 -3
- package/src/cli/index.ts +8 -10
- package/src/cli/init.ts +2 -2
- package/src/cli/internal-command.ts +29 -2
- package/src/cli/message-command.ts +2 -1
- package/src/cli/message-mcp-command.ts +29 -0
- package/src/cli/provider-cc-switch-import.ts +185 -0
- package/src/cli/provider.ts +5 -0
- package/src/cli/registry.ts +2 -1
- package/src/cli/restart-scope.ts +2 -2
- package/src/cli/root.ts +6 -6
- package/src/cli/stop-approval.ts +15 -1
- package/src/cli/v2.ts +69 -19
- package/src/client/machine-api.ts +2 -2
- package/src/clients/config-export.ts +14 -3
- package/src/codex/account-cooldown-response.ts +18 -0
- package/src/codex/account-store.ts +1 -0
- package/src/codex/app-server-restart-service.ts +2 -2
- package/src/codex/auth-api/login-flow.ts +2 -2
- package/src/codex/auth-api/pool-quota-probe.ts +2 -2
- package/src/codex/auth-context-provider.ts +15 -0
- package/src/codex/auth-context.ts +14 -23
- package/src/codex/catalog/bundled.ts +10 -3
- package/src/codex/catalog/metadata.ts +4 -5
- package/src/codex/catalog/native-omission.ts +28 -0
- package/src/codex/catalog/native-template.ts +58 -0
- package/src/codex/catalog/parsing.ts +3 -29
- package/src/codex/catalog/provider-models.ts +2 -1
- package/src/codex/catalog/retained-sync.ts +15 -5
- package/src/codex/catalog/write-audit.ts +18 -18
- package/src/codex/cli-install-provenance.ts +46 -45
- package/src/codex/cli-update-artifacts.ts +8 -6
- package/src/codex/cli-update-job-store-windows.ts +99 -27
- package/src/codex/cli-update-job-worker.ts +3 -11
- package/src/codex/cli-update-recovery.ts +54 -8
- package/src/codex/cli-update-selection-gate.ts +74 -4
- package/src/codex/cli-windows-plan-provenance.ts +37 -19
- package/src/codex/codex-home-owner.ts +9 -8
- package/src/codex/convergence.ts +13 -3
- package/src/codex/coordinator-doctor.ts +14 -8
- package/src/codex/desktop-app/handoff.ts +1 -1
- package/src/codex/desktop-app-restart.ts +11 -1
- package/src/codex/exec-boundary.ts +26 -5
- package/src/codex/forward-transport-headers.ts +33 -33
- package/src/codex/history-provider.ts +11 -10
- package/src/codex/inject/bounded-config-reader.ts +14 -13
- package/src/codex/installation-id.ts +72 -0
- package/src/codex/main-account.ts +6 -6
- package/src/codex/native-main-lock-file.ts +13 -12
- package/src/codex/native-residue.ts +18 -14
- package/src/codex/orca-auth-source.ts +8 -7
- package/src/codex/quota-types.ts +5 -0
- package/src/codex/quota.ts +49 -7
- package/src/codex/role-auto-assign.ts +50 -26
- package/src/codex/role-capability.ts +160 -0
- package/src/codex/role-sizing.ts +24 -6
- package/src/codex/routing/cooldown-math.ts +3 -2
- package/src/codex/runtime.ts +43 -3
- package/src/codex/shim-fingerprint.ts +11 -9
- package/src/codex/shim-inspect.ts +3 -2
- package/src/codex/shim-restore-lock.ts +11 -14
- package/src/codex/shim-state-file.ts +22 -14
- package/src/codex/shim-wrapper-write.ts +7 -6
- package/src/codex/shim.ts +25 -2
- package/src/codex/transition-state.ts +5 -4
- package/src/combos/failover.ts +43 -4
- package/src/config/atomic-write.ts +38 -7
- package/src/config/diagnostics.ts +3 -0
- package/src/config/initialize.ts +6 -6
- package/src/config/load-degrade.ts +2 -0
- package/src/config/process-state.ts +23 -5
- package/src/config/salvage.ts +1 -0
- package/src/config/schema/config-schema.ts +29 -1
- package/src/config/schema/leaf-validators.ts +7 -0
- package/src/config/schema/workflow-budget.ts +43 -0
- package/src/config/tracked-runtime-inspection.ts +188 -0
- package/src/generated/compatibility-version.json +380 -244
- package/src/grok/sync.ts +10 -1
- package/src/integrations/aside-profile-context.ts +1 -1
- package/src/integrations/droid-settings.ts +4 -4
- package/src/integrations/hermes-profiles.ts +3 -3
- package/src/lib/bounded-file-read.ts +3 -9
- package/src/lib/bun-runtime-preflight.ts +9 -8
- package/src/lib/file-identity.ts +15 -0
- package/src/lib/local-chat-completion.ts +8 -6
- package/src/lib/local-destinations.ts +32 -3
- package/src/lib/redact-folding.ts +9 -0
- package/src/lib/spend-pool-alias-validation.ts +6 -6
- package/src/lib/state-store-registrations.ts +2 -0
- package/src/lib/test-home-guard.ts +37 -9
- package/src/lib/windows-secret-acl.ts +49 -31
- package/src/lib/workflow-budget-config.ts +39 -0
- package/src/local-credentials/generation.ts +6 -2
- package/src/local-credentials/inventory.ts +132 -8
- package/src/messaging/mcp-queue-rpc.ts +102 -0
- package/src/messaging/mcp-queue-server.ts +42 -0
- package/src/messaging/mcp-queue-tools.ts +39 -0
- package/src/messaging/remote-forward-failure.ts +35 -0
- package/src/messaging/remote-ports.ts +27 -5
- package/src/messaging/remote-process.ts +30 -4
- package/src/messaging/remote-tunnels.ts +80 -15
- package/src/oauth/anthropic-identity.ts +2 -6
- package/src/oauth/antigravity-discovery-diagnostics.ts +65 -0
- package/src/oauth/google-antigravity.ts +23 -10
- package/src/oauth/index.ts +7 -0
- package/src/oauth/kiro-device-login.ts +87 -30
- package/src/oauth/kiro-iam-identity-center.ts +107 -0
- package/src/oauth/store.ts +9 -7
- package/src/providers/account-quota-disk.ts +18 -4
- package/src/providers/anthropic-subscription.ts +25 -0
- package/src/providers/cc-switch-import-bytes.ts +991 -0
- package/src/providers/cc-switch-import-source.ts +1083 -0
- package/src/providers/cc-switch-import.ts +942 -0
- package/src/providers/claude-cli-usage.ts +15 -67
- package/src/providers/derive.ts +6 -0
- package/src/providers/model-discovery-diagnostic.ts +4 -0
- package/src/providers/model-discovery.ts +4 -4
- package/src/providers/model-rename-fields.ts +2 -0
- package/src/providers/model-rename-migration.ts +41 -6
- package/src/providers/quota/anthropic-decision-windows.ts +5 -19
- package/src/providers/quota/anthropic-usage-windows.ts +55 -0
- package/src/providers/quota/report-cache.ts +17 -4
- package/src/providers/quota.ts +2 -2
- package/src/providers/reasoning-metadata.ts +31 -15
- package/src/providers/registry/entries-core.ts +1 -1
- package/src/providers/registry/entries-extended.ts +1 -1
- package/src/providers/registry/model-ids.ts +1 -0
- package/src/providers/registry/model-seeds.ts +2 -1
- package/src/providers/registry/types.ts +3 -1
- package/src/providers/resolved-model-policy.ts +2 -2
- package/src/providers/routed-config.ts +2 -0
- package/src/providers/stale-model-roster-migration.ts +5 -1
- package/src/providers/xai-transport.ts +4 -4
- package/src/remote-control/workspace-codex-runtime.ts +2 -2
- package/src/remote-control/workspace-executor.ts +14 -13
- package/src/responses/custom-tool-compat.ts +2 -1
- package/src/responses/item-provenance.ts +79 -0
- package/src/responses/namespace-tool-compat.ts +21 -3
- package/src/responses/parser-tools.ts +1 -0
- package/src/responses/schema.ts +5 -2
- package/src/router.ts +21 -2
- package/src/routing/analytics.ts +3 -5
- package/src/routing/fallback-policy.ts +7 -3
- package/src/routing/health.ts +5 -3
- package/src/routing/history/build-file.ts +6 -0
- package/src/routing/history/indexer.ts +158 -31
- package/src/routing/history/ingest.ts +1 -1
- package/src/routing/history/integrity.ts +208 -0
- package/src/routing/history/rebuild-job.ts +20 -6
- package/src/routing/history/rebuild-protocol.ts +2 -1
- package/src/routing/history/rebuild-worker.ts +18 -0
- package/src/routing/history/sqlite-errors.ts +9 -0
- package/src/server/admission-model-scope.ts +21 -4
- package/src/server/advisor-admission-scope.ts +29 -0
- package/src/server/audio-dictation.ts +3 -0
- package/src/server/audio-live.ts +8 -2
- package/src/server/audio-upstream.ts +2 -0
- package/src/server/auth-cors.ts +5 -2
- package/src/server/capture-admission-policy.ts +91 -0
- package/src/server/chat-completions.ts +33 -7
- package/src/server/claude-messages.ts +93 -2
- package/src/server/codex-model-list.ts +2 -1
- package/src/server/configured-credentials.ts +5 -0
- package/src/server/context-history.ts +9 -6
- package/src/server/images.ts +14 -5
- package/src/server/index/live-sideband.ts +16 -2
- package/src/server/index/serve-options.ts +13 -2
- package/src/server/index/websocket-handler.ts +4 -1
- package/src/server/live.ts +30 -5
- package/src/server/management/agent-settings-routes.ts +34 -9
- package/src/server/management/codex-agent-role-routes.ts +1 -0
- package/src/server/management/codex-role-auto-assign.ts +50 -6
- package/src/server/management/config-routes.ts +15 -4
- package/src/server/management/context.ts +3 -0
- package/src/server/management/native-integration-routes.ts +22 -0
- package/src/server/management/oauth-account-routes.ts +20 -4
- package/src/server/management/provider-overwrite-carry.ts +21 -0
- package/src/server/management/provider-routes.ts +3 -1
- package/src/server/management/route-registry.ts +2 -0
- package/src/server/management/shared.ts +17 -1
- package/src/server/management/workflow-budget-routes.ts +70 -3
- package/src/server/messages-native-eligibility.ts +6 -5
- package/src/server/messages-native-scope.ts +6 -1
- package/src/server/messages-shared.ts +57 -17
- package/src/server/persistent-gui-session.ts +4 -4
- package/src/server/request-log.ts +30 -2
- package/src/server/responses/adapter-delivery.ts +4 -0
- package/src/server/responses/adapter-dispatch.ts +5 -0
- package/src/server/responses/advisor-plan-slot.ts +4 -0
- package/src/server/responses/advisor-slot.ts +73 -46
- package/src/server/responses/codex-auth-error.ts +9 -1
- package/src/server/responses/combo-required-tool-contract.ts +39 -0
- package/src/server/responses/compact.ts +41 -20
- package/src/server/responses/core-codex-account.ts +17 -6
- package/src/server/responses/core-combo-failure.ts +2 -0
- package/src/server/responses/core-combo.ts +70 -5
- package/src/server/responses/core-lifetime.ts +4 -0
- package/src/server/responses/core-normalize.ts +7 -1
- package/src/server/responses/core-options.ts +9 -0
- package/src/server/responses/core.ts +2 -0
- package/src/server/responses/jev-model-invoke.ts +4 -2
- package/src/server/responses/passthrough-build-error.ts +36 -0
- package/src/server/responses/passthrough-dispatch.ts +10 -24
- package/src/server/responses/policy-fallback.ts +2 -0
- package/src/server/responses/request-prepare.ts +4 -5
- package/src/server/responses/request-send-budget.ts +2 -1
- package/src/server/responses/request-sidecar-auth.ts +4 -1
- package/src/server/responses/request-transport.ts +2 -3
- package/src/server/responses/run-turn-execution.ts +4 -0
- package/src/server/responses/sidecar-execution.ts +21 -5
- package/src/server/responses-snapshot-repair.ts +18 -4
- package/src/server/responses-undeclared-tool-guard.ts +4 -0
- package/src/server/search.ts +13 -4
- package/src/server/workflow-refusal.ts +2 -1
- package/src/server/ws-bridge.ts +5 -2
- package/src/service/state-lock.ts +12 -11
- package/src/service-manager-probe.ts +53 -8
- package/src/types/admission-policy.ts +13 -0
- package/src/types/config.ts +25 -0
- package/src/types/provider.ts +10 -0
- package/src/types/request.ts +7 -0
- package/src/types.ts +1 -0
- package/src/update/job.ts +20 -0
- package/src/update/worker-launch.ts +71 -1
- package/src/usage/log.ts +25 -4
- package/src/vision/describe.ts +4 -7
- package/src/vision/index.ts +2 -0
- package/src/vision/plan.ts +4 -0
- package/src/vision/routed-describe.ts +38 -23
- package/src/web-search/executor.ts +4 -7
- package/src/web-search/loop.ts +104 -9
- package/src/web-search/parse.ts +10 -2
- package/gui/dist/assets/App-DMps4OLk.css +0 -1
- package/gui/dist/assets/App-DmvwlhQq.js +0 -58
- package/gui/dist/assets/index-3EPO_KbX.js +0 -94
- package/gui/dist/assets/quota-summary-BHvWg9mi.js +0 -1
|
@@ -0,0 +1,991 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* Pure byte-level validators, RFC 8259 JSON string/key scanners, and Codex TOML byte parser
|
|
3
|
+
* for keyless CC-Switch provider import.
|
|
4
|
+
*/
|
|
5
|
+
export class CcSwitchImportError extends Error {
|
|
6
|
+
constructor(message: string) {
|
|
7
|
+
super(message);
|
|
8
|
+
this.name = "CcSwitchImportError";
|
|
9
|
+
}
|
|
10
|
+
}
|
|
11
|
+
|
|
12
|
+
export type CcSwitchInvalidReason =
|
|
13
|
+
| "missing_base_url"
|
|
14
|
+
| "invalid_base_url"
|
|
15
|
+
| "private_network_refused"
|
|
16
|
+
| "invalid_provider_name"
|
|
17
|
+
| "unsupported_app_type"
|
|
18
|
+
| "ambiguous_codex_provider"
|
|
19
|
+
| "disallowed_metadata"
|
|
20
|
+
| "malformed_entry";
|
|
21
|
+
|
|
22
|
+
export const METADATA_REFUSED_SENTINEL = "__METADATA_REFUSED__";
|
|
23
|
+
export const URL_SYNTAX_REFUSED_SENTINEL = "__URL_REFUSED__";
|
|
24
|
+
const MAX_SQLITE_BYTES = 32 * 1024 * 1024;
|
|
25
|
+
export const MAX_CODEX_TOML_BYTES = 64 * 1024;
|
|
26
|
+
|
|
27
|
+
export type MetadataFieldKind = "id" | "app" | "model" | "url" | "wire";
|
|
28
|
+
|
|
29
|
+
function hasControlChars(value: string): boolean {
|
|
30
|
+
for (let i = 0; i < value.length; i++) {
|
|
31
|
+
const c = value.charCodeAt(i);
|
|
32
|
+
if (c <= 0x1f || c === 0x7f) return true;
|
|
33
|
+
}
|
|
34
|
+
return false;
|
|
35
|
+
}
|
|
36
|
+
|
|
37
|
+
function isDigitByte(b: number): boolean {
|
|
38
|
+
return b >= 0x30 && b <= 0x39;
|
|
39
|
+
}
|
|
40
|
+
function isLowerByte(b: number): boolean {
|
|
41
|
+
return b >= 0x61 && b <= 0x7a;
|
|
42
|
+
}
|
|
43
|
+
function isUpperByte(b: number): boolean {
|
|
44
|
+
return b >= 0x41 && b <= 0x5a;
|
|
45
|
+
}
|
|
46
|
+
function isAlphaByte(b: number): boolean {
|
|
47
|
+
return isLowerByte(b) || isUpperByte(b);
|
|
48
|
+
}
|
|
49
|
+
function isHexByte(b: number): boolean {
|
|
50
|
+
return isDigitByte(b) || (b >= 0x61 && b <= 0x66) || (b >= 0x41 && b <= 0x46);
|
|
51
|
+
}
|
|
52
|
+
function toLowerByte(b: number): number {
|
|
53
|
+
return isUpperByte(b) ? b + 32 : b;
|
|
54
|
+
}
|
|
55
|
+
|
|
56
|
+
export function equalsAsciiBytes(slice: Uint8Array, ascii: string): boolean {
|
|
57
|
+
if (slice.length !== ascii.length) return false;
|
|
58
|
+
for (let i = 0; i < ascii.length; i++) {
|
|
59
|
+
if (slice[i] !== ascii.charCodeAt(i)) return false;
|
|
60
|
+
}
|
|
61
|
+
return true;
|
|
62
|
+
}
|
|
63
|
+
|
|
64
|
+
export function parseHex4Bytes(bytes: Uint8Array, offset: number): number {
|
|
65
|
+
if (offset + 4 > bytes.length) return -1;
|
|
66
|
+
let out = 0;
|
|
67
|
+
for (let i = 0; i < 4; i++) {
|
|
68
|
+
const b = bytes[offset + i]!;
|
|
69
|
+
let v: number;
|
|
70
|
+
if (b >= 0x30 && b <= 0x39) v = b - 0x30;
|
|
71
|
+
else if (b >= 0x41 && b <= 0x46) v = b - 0x41 + 10;
|
|
72
|
+
else if (b >= 0x61 && b <= 0x66) v = b - 0x61 + 10;
|
|
73
|
+
else return -1;
|
|
74
|
+
out = (out << 4) | v;
|
|
75
|
+
}
|
|
76
|
+
return out;
|
|
77
|
+
}
|
|
78
|
+
|
|
79
|
+
export function encodeCodePointUtf8(cp: number, target: Uint8Array, offset: number): number {
|
|
80
|
+
if (cp <= 0x7f) {
|
|
81
|
+
target[offset] = cp;
|
|
82
|
+
return 1;
|
|
83
|
+
}
|
|
84
|
+
if (cp <= 0x7ff) {
|
|
85
|
+
target[offset] = 0xc0 | (cp >> 6);
|
|
86
|
+
target[offset + 1] = 0x80 | (cp & 0x3f);
|
|
87
|
+
return 2;
|
|
88
|
+
}
|
|
89
|
+
if (cp <= 0xffff) {
|
|
90
|
+
target[offset] = 0xe0 | (cp >> 12);
|
|
91
|
+
target[offset + 1] = 0x80 | ((cp >> 6) & 0x3f);
|
|
92
|
+
target[offset + 2] = 0x80 | (cp & 0x3f);
|
|
93
|
+
return 3;
|
|
94
|
+
}
|
|
95
|
+
target[offset] = 0xf0 | (cp >> 18);
|
|
96
|
+
target[offset + 1] = 0x80 | ((cp >> 12) & 0x3f);
|
|
97
|
+
target[offset + 2] = 0x80 | ((cp >> 6) & 0x3f);
|
|
98
|
+
target[offset + 3] = 0x80 | (cp & 0x3f);
|
|
99
|
+
return 4;
|
|
100
|
+
}
|
|
101
|
+
|
|
102
|
+
/**
|
|
103
|
+
* Strict RFC 8259 + UTF-8 byte-level JSON string validator.
|
|
104
|
+
* Validates escapes (including paired UTF-16 surrogates) and multi-byte UTF-8 sequences
|
|
105
|
+
* without decoding string contents into JavaScript strings.
|
|
106
|
+
*/
|
|
107
|
+
export function validateUtf8AndJsonStringBounds(
|
|
108
|
+
bytes: Uint8Array,
|
|
109
|
+
quotePos: number,
|
|
110
|
+
): { start: number; end: number; hasEscapes: boolean; nextPos: number } | null {
|
|
111
|
+
if (quotePos >= bytes.length || bytes[quotePos] !== 0x22) return null;
|
|
112
|
+
let pos = quotePos + 1;
|
|
113
|
+
const start = pos;
|
|
114
|
+
let hasEscapes = false;
|
|
115
|
+
while (pos < bytes.length) {
|
|
116
|
+
const b = bytes[pos]!;
|
|
117
|
+
if (b < 0x20) return null;
|
|
118
|
+
if (b === 0x22) {
|
|
119
|
+
return { start, end: pos, hasEscapes, nextPos: pos + 1 };
|
|
120
|
+
}
|
|
121
|
+
if (b === 0x5c) {
|
|
122
|
+
hasEscapes = true;
|
|
123
|
+
pos++;
|
|
124
|
+
if (pos >= bytes.length) return null;
|
|
125
|
+
const esc = bytes[pos]!;
|
|
126
|
+
pos++;
|
|
127
|
+
if (
|
|
128
|
+
esc === 0x22 || esc === 0x5c || esc === 0x2f
|
|
129
|
+
|| esc === 0x62 || esc === 0x66 || esc === 0x6e || esc === 0x72 || esc === 0x74
|
|
130
|
+
) {
|
|
131
|
+
continue;
|
|
132
|
+
}
|
|
133
|
+
if (esc === 0x75) {
|
|
134
|
+
const cu = parseHex4Bytes(bytes, pos);
|
|
135
|
+
if (cu < 0) return null;
|
|
136
|
+
pos += 4;
|
|
137
|
+
if (cu >= 0xdc00 && cu <= 0xdfff) return null;
|
|
138
|
+
if (cu >= 0xd800 && cu <= 0xdbff) {
|
|
139
|
+
if (pos + 6 > bytes.length || bytes[pos] !== 0x5c || bytes[pos + 1] !== 0x75) return null;
|
|
140
|
+
const low = parseHex4Bytes(bytes, pos + 2);
|
|
141
|
+
if (low < 0xdc00 || low > 0xdfff) return null;
|
|
142
|
+
pos += 6;
|
|
143
|
+
}
|
|
144
|
+
continue;
|
|
145
|
+
}
|
|
146
|
+
return null;
|
|
147
|
+
}
|
|
148
|
+
if (b < 0x80) {
|
|
149
|
+
pos++;
|
|
150
|
+
continue;
|
|
151
|
+
}
|
|
152
|
+
if (b >= 0xc2 && b <= 0xdf) {
|
|
153
|
+
if (pos + 1 >= bytes.length) return null;
|
|
154
|
+
const c1 = bytes[pos + 1]!;
|
|
155
|
+
if ((c1 & 0xc0) !== 0x80) return null;
|
|
156
|
+
pos += 2;
|
|
157
|
+
continue;
|
|
158
|
+
}
|
|
159
|
+
if (b >= 0xe0 && b <= 0xef) {
|
|
160
|
+
if (pos + 2 >= bytes.length) return null;
|
|
161
|
+
const c1 = bytes[pos + 1]!;
|
|
162
|
+
const c2 = bytes[pos + 2]!;
|
|
163
|
+
if ((c1 & 0xc0) !== 0x80 || (c2 & 0xc0) !== 0x80) return null;
|
|
164
|
+
if (b === 0xe0 && c1 < 0xa0) return null;
|
|
165
|
+
if (b === 0xed && c1 >= 0xa0) return null;
|
|
166
|
+
pos += 3;
|
|
167
|
+
continue;
|
|
168
|
+
}
|
|
169
|
+
if (b >= 0xf0 && b <= 0xf4) {
|
|
170
|
+
if (pos + 3 >= bytes.length) return null;
|
|
171
|
+
const c1 = bytes[pos + 1]!;
|
|
172
|
+
const c2 = bytes[pos + 2]!;
|
|
173
|
+
const c3 = bytes[pos + 3]!;
|
|
174
|
+
if ((c1 & 0xc0) !== 0x80 || (c2 & 0xc0) !== 0x80 || (c3 & 0xc0) !== 0x80) return null;
|
|
175
|
+
if (b === 0xf0 && c1 < 0x90) return null;
|
|
176
|
+
if (b === 0xf4 && c1 > 0x8f) return null;
|
|
177
|
+
pos += 4;
|
|
178
|
+
continue;
|
|
179
|
+
}
|
|
180
|
+
return null;
|
|
181
|
+
}
|
|
182
|
+
return null;
|
|
183
|
+
}
|
|
184
|
+
|
|
185
|
+
export function validateJsonPrimitiveBytes(bytes: Uint8Array, start: number, end: number): boolean {
|
|
186
|
+
const slice = bytes.subarray(start, end);
|
|
187
|
+
if (slice.length === 0) return false;
|
|
188
|
+
if (equalsAsciiBytes(slice, "true") || equalsAsciiBytes(slice, "false") || equalsAsciiBytes(slice, "null")) {
|
|
189
|
+
return true;
|
|
190
|
+
}
|
|
191
|
+
let i = 0;
|
|
192
|
+
if (slice[i] === 0x2d) {
|
|
193
|
+
i++;
|
|
194
|
+
if (i >= slice.length) return false;
|
|
195
|
+
}
|
|
196
|
+
if (slice[i] === 0x30) {
|
|
197
|
+
i++;
|
|
198
|
+
} else if (slice[i]! >= 0x31 && slice[i]! <= 0x39) {
|
|
199
|
+
while (i < slice.length && isDigitByte(slice[i]!)) i++;
|
|
200
|
+
} else {
|
|
201
|
+
return false;
|
|
202
|
+
}
|
|
203
|
+
if (i < slice.length && slice[i] === 0x2e) {
|
|
204
|
+
i++;
|
|
205
|
+
if (i >= slice.length || !isDigitByte(slice[i]!)) return false;
|
|
206
|
+
while (i < slice.length && isDigitByte(slice[i]!)) i++;
|
|
207
|
+
}
|
|
208
|
+
if (i < slice.length && (slice[i] === 0x65 || slice[i] === 0x45)) {
|
|
209
|
+
i++;
|
|
210
|
+
if (i < slice.length && (slice[i] === 0x2b || slice[i] === 0x2d)) i++;
|
|
211
|
+
if (i >= slice.length || !isDigitByte(slice[i]!)) return false;
|
|
212
|
+
while (i < slice.length && isDigitByte(slice[i]!)) i++;
|
|
213
|
+
}
|
|
214
|
+
return i === slice.length;
|
|
215
|
+
}
|
|
216
|
+
|
|
217
|
+
export function unescapeJsonStringBytesBounded(
|
|
218
|
+
bytes: Uint8Array,
|
|
219
|
+
bounds: { start: number; end: number; hasEscapes: boolean },
|
|
220
|
+
maxBytes: number,
|
|
221
|
+
): Uint8Array | null {
|
|
222
|
+
const rawLen = bounds.end - bounds.start;
|
|
223
|
+
if (rawLen > maxBytes * 6) return null;
|
|
224
|
+
const out = new Uint8Array(Math.max(rawLen, 4));
|
|
225
|
+
let r = bounds.start;
|
|
226
|
+
let w = 0;
|
|
227
|
+
while (r < bounds.end) {
|
|
228
|
+
const b = bytes[r]!;
|
|
229
|
+
if (b !== 0x5c) {
|
|
230
|
+
out[w++] = b;
|
|
231
|
+
r++;
|
|
232
|
+
continue;
|
|
233
|
+
}
|
|
234
|
+
r++;
|
|
235
|
+
const esc = bytes[r]!;
|
|
236
|
+
r++;
|
|
237
|
+
if (esc === 0x22 || esc === 0x5c || esc === 0x2f) out[w++] = esc;
|
|
238
|
+
else if (esc === 0x62) out[w++] = 0x08;
|
|
239
|
+
else if (esc === 0x66) out[w++] = 0x0c;
|
|
240
|
+
else if (esc === 0x6e) out[w++] = 0x0a;
|
|
241
|
+
else if (esc === 0x72) out[w++] = 0x0d;
|
|
242
|
+
else if (esc === 0x74) out[w++] = 0x09;
|
|
243
|
+
else if (esc === 0x75) {
|
|
244
|
+
let cp = parseHex4Bytes(bytes, r);
|
|
245
|
+
if (cp < 0) { out.fill(0); return null; }
|
|
246
|
+
r += 4;
|
|
247
|
+
if (cp >= 0xd800 && cp <= 0xdbff) {
|
|
248
|
+
const low = parseHex4Bytes(bytes, r + 2);
|
|
249
|
+
if (low < 0xdc00 || low > 0xdfff) { out.fill(0); return null; }
|
|
250
|
+
r += 6;
|
|
251
|
+
cp = ((cp - 0xd800) << 10) + (low - 0xdc00) + 0x10000;
|
|
252
|
+
} else if (cp >= 0xdc00 && cp <= 0xdfff) {
|
|
253
|
+
out.fill(0);
|
|
254
|
+
return null;
|
|
255
|
+
}
|
|
256
|
+
w += encodeCodePointUtf8(cp, out, w);
|
|
257
|
+
} else {
|
|
258
|
+
out.fill(0);
|
|
259
|
+
return null;
|
|
260
|
+
}
|
|
261
|
+
}
|
|
262
|
+
if (w > maxBytes) {
|
|
263
|
+
out.fill(0);
|
|
264
|
+
return null;
|
|
265
|
+
}
|
|
266
|
+
const result = new Uint8Array(w);
|
|
267
|
+
result.set(out.subarray(0, w));
|
|
268
|
+
out.fill(0);
|
|
269
|
+
return result;
|
|
270
|
+
}
|
|
271
|
+
|
|
272
|
+
export function matchKnownJsonKeyBytes<T extends string>(
|
|
273
|
+
bytes: Uint8Array,
|
|
274
|
+
bounds: { start: number; end: number; hasEscapes: boolean },
|
|
275
|
+
allowed: readonly T[],
|
|
276
|
+
): T | null {
|
|
277
|
+
if (!bounds.hasEscapes) {
|
|
278
|
+
const raw = bytes.subarray(bounds.start, bounds.end);
|
|
279
|
+
for (const candidate of allowed) {
|
|
280
|
+
if (equalsAsciiBytes(raw, candidate)) return candidate;
|
|
281
|
+
}
|
|
282
|
+
return null;
|
|
283
|
+
}
|
|
284
|
+
const unescaped = unescapeJsonStringBytesBounded(bytes, bounds, 48);
|
|
285
|
+
if (!unescaped) return null;
|
|
286
|
+
try {
|
|
287
|
+
for (const candidate of allowed) {
|
|
288
|
+
if (equalsAsciiBytes(unescaped, candidate)) return candidate;
|
|
289
|
+
}
|
|
290
|
+
return null;
|
|
291
|
+
} finally {
|
|
292
|
+
unescaped.fill(0);
|
|
293
|
+
}
|
|
294
|
+
}
|
|
295
|
+
|
|
296
|
+
const FORBIDDEN_SUBSTRINGS_LOWER = [
|
|
297
|
+
"sk-", "rk-", "pk-", "ak-", "ghp_", "gho_", "github_pat_", "xoxb-", "xoxp-", "xoxa-", "xoxr-", "xoxs-",
|
|
298
|
+
"aiza", "eyj", "bearer", "secret", "apikey", "api_key", "passwd", "password", "private_key",
|
|
299
|
+
"access_token", "refresh_token", "auth_token",
|
|
300
|
+
].map(s => Buffer.from(s, "ascii"));
|
|
301
|
+
|
|
302
|
+
function containsForbiddenBytes(slice: Uint8Array): boolean {
|
|
303
|
+
for (const pat of FORBIDDEN_SUBSTRINGS_LOWER) {
|
|
304
|
+
if (slice.length < pat.length) continue;
|
|
305
|
+
for (let i = 0; i <= slice.length - pat.length; i++) {
|
|
306
|
+
let match = true;
|
|
307
|
+
for (let j = 0; j < pat.length; j++) {
|
|
308
|
+
if (toLowerByte(slice[i + j]!) !== pat[j]!) {
|
|
309
|
+
match = false;
|
|
310
|
+
break;
|
|
311
|
+
}
|
|
312
|
+
}
|
|
313
|
+
if (match) return true;
|
|
314
|
+
}
|
|
315
|
+
}
|
|
316
|
+
// Reject 3+ grouped 4-hex segments like a1b2-c3d4-e5f6 (UUID / grouped hex key).
|
|
317
|
+
if (slice.length >= 14) {
|
|
318
|
+
for (let i = 0; i <= slice.length - 14; i++) {
|
|
319
|
+
if (
|
|
320
|
+
isHexByte(slice[i]!) && isHexByte(slice[i + 1]!) && isHexByte(slice[i + 2]!) && isHexByte(slice[i + 3]!)
|
|
321
|
+
&& slice[i + 4] === 0x2d
|
|
322
|
+
&& isHexByte(slice[i + 5]!) && isHexByte(slice[i + 6]!) && isHexByte(slice[i + 7]!) && isHexByte(slice[i + 8]!)
|
|
323
|
+
&& slice[i + 9] === 0x2d
|
|
324
|
+
&& isHexByte(slice[i + 10]!) && isHexByte(slice[i + 11]!) && isHexByte(slice[i + 12]!) && isHexByte(slice[i + 13]!)
|
|
325
|
+
) {
|
|
326
|
+
return true;
|
|
327
|
+
}
|
|
328
|
+
}
|
|
329
|
+
}
|
|
330
|
+
return false;
|
|
331
|
+
}
|
|
332
|
+
|
|
333
|
+
const ALLOWED_API_TERMINAL_PATH_SEGMENTS = [
|
|
334
|
+
"api", "openai", "anthropic", "codex", "chat", "responses", "gateway", "compat", "models", "inference", "llm", "proxy",
|
|
335
|
+
] as const;
|
|
336
|
+
|
|
337
|
+
function isCanonicalUuidBytes(slice: Uint8Array): boolean {
|
|
338
|
+
if (slice.length !== 36) return false;
|
|
339
|
+
for (let i = 0; i < 36; i++) {
|
|
340
|
+
const b = slice[i]!;
|
|
341
|
+
if (i === 8 || i === 13 || i === 18 || i === 23) {
|
|
342
|
+
if (b !== 0x2d) return false;
|
|
343
|
+
} else if (!isHexByte(b)) {
|
|
344
|
+
return false;
|
|
345
|
+
}
|
|
346
|
+
}
|
|
347
|
+
return true;
|
|
348
|
+
}
|
|
349
|
+
|
|
350
|
+
function isModelParamSizeSeg(slice: Uint8Array, start: number, end: number): boolean {
|
|
351
|
+
const n = end - start;
|
|
352
|
+
if (n < 2 || n > 4 || slice[end - 1] !== 0x62) return false;
|
|
353
|
+
const dStart = slice[start] === 0x61 ? start + 1 : start;
|
|
354
|
+
if (dStart >= end - 1 || slice[dStart] === 0x30) return false;
|
|
355
|
+
for (let k = dStart; k < end - 1; k++) if (!isDigitByte(slice[k]!)) return false;
|
|
356
|
+
return true;
|
|
357
|
+
}
|
|
358
|
+
|
|
359
|
+
function isApiVersionSegmentBytes(seg: Uint8Array): boolean {
|
|
360
|
+
// Matches v1..v9, v1.1, v1beta, v1beta1, etc.
|
|
361
|
+
if (seg.length < 2 || seg.length > 10 || seg[0] !== 0x76 || !(seg[1]! >= 0x31 && seg[1]! <= 0x39)) {
|
|
362
|
+
return false;
|
|
363
|
+
}
|
|
364
|
+
for (let i = 2; i < seg.length; i++) {
|
|
365
|
+
const b = seg[i]!;
|
|
366
|
+
if (!isLowerByte(b) && !isDigitByte(b) && b !== 0x2e) return false;
|
|
367
|
+
}
|
|
368
|
+
return seg[seg.length - 1] !== 0x2e;
|
|
369
|
+
}
|
|
370
|
+
|
|
371
|
+
function isAllowedTerminalUrlSegmentBytes(seg: Uint8Array): boolean {
|
|
372
|
+
if (isApiVersionSegmentBytes(seg)) return true;
|
|
373
|
+
for (const allowed of ALLOWED_API_TERMINAL_PATH_SEGMENTS) {
|
|
374
|
+
if (equalsAsciiBytes(seg, allowed)) return true;
|
|
375
|
+
}
|
|
376
|
+
return false;
|
|
377
|
+
}
|
|
378
|
+
|
|
379
|
+
function validateAuthorityBytes(auth: Uint8Array): boolean {
|
|
380
|
+
if (auth.length === 0 || auth.length > 190) return false;
|
|
381
|
+
let hostEnd = auth.length;
|
|
382
|
+
if (auth[0] === 0x5b) {
|
|
383
|
+
// Bracketed IPv6 literal: [hex:...] with optional :port
|
|
384
|
+
let closeIdx = -1;
|
|
385
|
+
let sawColon = false;
|
|
386
|
+
for (let i = 1; i < auth.length; i++) {
|
|
387
|
+
const b = auth[i]!;
|
|
388
|
+
if (b === 0x5d) { closeIdx = i; break; }
|
|
389
|
+
if (b === 0x3a) sawColon = true;
|
|
390
|
+
else if (!isHexByte(b) && b !== 0x2e) return false;
|
|
391
|
+
}
|
|
392
|
+
if (closeIdx < 3 || !sawColon) return false;
|
|
393
|
+
if (closeIdx === auth.length - 1) return true;
|
|
394
|
+
if (auth[closeIdx + 1] !== 0x3a) return false;
|
|
395
|
+
hostEnd = closeIdx + 1;
|
|
396
|
+
} else {
|
|
397
|
+
const colonIdx = auth.indexOf(0x3a);
|
|
398
|
+
if (colonIdx === 0) return false;
|
|
399
|
+
const host = colonIdx > 0 ? auth.subarray(0, colonIdx) : auth;
|
|
400
|
+
if (host.length === 0 || host.length > 180) return false;
|
|
401
|
+
if (host[0] === 0x2e || host[0] === 0x2d || host[host.length - 1] === 0x2d) return false;
|
|
402
|
+
for (let i = 0; i < host.length; i++) {
|
|
403
|
+
const b = host[i]!;
|
|
404
|
+
if (!isAlphaByte(b) && !isDigitByte(b) && b !== 0x2e && b !== 0x2d) return false;
|
|
405
|
+
if (b === 0x2e && i > 0 && host[i - 1] === 0x2e) return false;
|
|
406
|
+
}
|
|
407
|
+
if (colonIdx < 0) return true;
|
|
408
|
+
hostEnd = colonIdx;
|
|
409
|
+
}
|
|
410
|
+
// Validate :port (1..65535)
|
|
411
|
+
const portSlice = auth.subarray(hostEnd + 1);
|
|
412
|
+
if (portSlice.length === 0 || portSlice.length > 5) return false;
|
|
413
|
+
let port = 0;
|
|
414
|
+
for (let i = 0; i < portSlice.length; i++) {
|
|
415
|
+
const b = portSlice[i]!;
|
|
416
|
+
if (!isDigitByte(b)) return false;
|
|
417
|
+
port = port * 10 + (b - 0x30);
|
|
418
|
+
}
|
|
419
|
+
return port >= 1 && port <= 65535;
|
|
420
|
+
}
|
|
421
|
+
|
|
422
|
+
/**
|
|
423
|
+
* Byte-level syntax & defense-in-depth validation enforced BEFORE decoding into a JavaScript string.
|
|
424
|
+
* Note: the primary security boundary is structural (secret-named fields are never read); this
|
|
425
|
+
* enforces narrow URL/identifier/model syntax as defense in depth.
|
|
426
|
+
*/
|
|
427
|
+
export function isAllowedMetadataBytes(slice: Uint8Array, kind: MetadataFieldKind): boolean {
|
|
428
|
+
const len = slice.length;
|
|
429
|
+
if (len === 0) return false;
|
|
430
|
+
for (let i = 0; i < len; i++) {
|
|
431
|
+
const b = slice[i]!;
|
|
432
|
+
if (b <= 0x20 || b >= 0x7f) return false;
|
|
433
|
+
}
|
|
434
|
+
// CC-Switch generates canonical 36-char randomUUID() primary keys for custom providers.
|
|
435
|
+
if (kind === "id" && isCanonicalUuidBytes(slice)) return true;
|
|
436
|
+
if (containsForbiddenBytes(slice)) return false;
|
|
437
|
+
|
|
438
|
+
if (kind === "app") {
|
|
439
|
+
if (len > 16) return false;
|
|
440
|
+
let hasLower = false;
|
|
441
|
+
let hasUpper = false;
|
|
442
|
+
for (let i = 0; i < len; i++) {
|
|
443
|
+
const b = slice[i]!;
|
|
444
|
+
if (!isAlphaByte(b) && b !== 0x2d && b !== 0x5f) return false;
|
|
445
|
+
if (isLowerByte(b)) hasLower = true;
|
|
446
|
+
if (isUpperByte(b)) hasUpper = true;
|
|
447
|
+
}
|
|
448
|
+
if (len >= 10 && hasLower && hasUpper) return false;
|
|
449
|
+
return true;
|
|
450
|
+
}
|
|
451
|
+
|
|
452
|
+
if (kind === "wire") {
|
|
453
|
+
if (len > 24) return false;
|
|
454
|
+
for (let i = 0; i < len; i++) {
|
|
455
|
+
const b = slice[i]!;
|
|
456
|
+
if (!isAlphaByte(b) && b !== 0x2d && b !== 0x5f) return false;
|
|
457
|
+
}
|
|
458
|
+
return true;
|
|
459
|
+
}
|
|
460
|
+
|
|
461
|
+
if (kind === "url") {
|
|
462
|
+
if (len < 8 || len > 256) return false;
|
|
463
|
+
// Must start with http:// or https://
|
|
464
|
+
const isHttp =
|
|
465
|
+
toLowerByte(slice[0]!) === 0x68 && toLowerByte(slice[1]!) === 0x74 && toLowerByte(slice[2]!) === 0x74
|
|
466
|
+
&& toLowerByte(slice[3]!) === 0x70;
|
|
467
|
+
if (!isHttp) return false;
|
|
468
|
+
let schemeEnd = 4;
|
|
469
|
+
if (toLowerByte(slice[4]!) === 0x73) schemeEnd = 5;
|
|
470
|
+
if (slice[schemeEnd] !== 0x3a || slice[schemeEnd + 1] !== 0x2f || slice[schemeEnd + 2] !== 0x2f) return false;
|
|
471
|
+
|
|
472
|
+
let firstPathSlash = -1;
|
|
473
|
+
for (let i = schemeEnd + 3; i < len; i++) {
|
|
474
|
+
const b = slice[i]!;
|
|
475
|
+
// Reject @, ?, #, %, ~, quotes, backslashes
|
|
476
|
+
if (b === 0x40 || b === 0x3f || b === 0x23 || b === 0x25 || b === 0x7e || b === 0x22 || b === 0x27 || b === 0x5c) return false;
|
|
477
|
+
if (b === 0x2f && firstPathSlash < 0) firstPathSlash = i;
|
|
478
|
+
}
|
|
479
|
+
const authorityEnd = firstPathSlash >= 0 ? firstPathSlash : len;
|
|
480
|
+
if (!validateAuthorityBytes(slice.subarray(schemeEnd + 3, authorityEnd))) return false;
|
|
481
|
+
if (firstPathSlash < 0) return true;
|
|
482
|
+
const pathLen = len - firstPathSlash;
|
|
483
|
+
if (pathLen === 1) return true;
|
|
484
|
+
if (pathLen > 48) return false;
|
|
485
|
+
|
|
486
|
+
const pathEnd = slice[len - 1] === 0x2f ? len - 1 : len;
|
|
487
|
+
if (pathEnd <= firstPathSlash + 1) return false; // Reject "//"
|
|
488
|
+
let segStart = firstPathSlash + 1;
|
|
489
|
+
let segCount = 0;
|
|
490
|
+
let totalPathDigits = 0;
|
|
491
|
+
let lastSeg: Uint8Array | null = null;
|
|
492
|
+
for (let i = firstPathSlash + 1; i <= pathEnd; i++) {
|
|
493
|
+
if (i < pathEnd && slice[i] !== 0x2f) continue;
|
|
494
|
+
const segLen = i - segStart;
|
|
495
|
+
if (segLen <= 0 || segLen > 20) return false; // Reject empty interior segment "//"
|
|
496
|
+
segCount++;
|
|
497
|
+
if (segCount > 4) return false;
|
|
498
|
+
const seg = slice.subarray(segStart, i);
|
|
499
|
+
if (equalsAsciiBytes(seg, ".") || equalsAsciiBytes(seg, "..")) return false;
|
|
500
|
+
const firstB = seg[0]!;
|
|
501
|
+
const lastB = seg[segLen - 1]!;
|
|
502
|
+
if ((!isLowerByte(firstB) && !isDigitByte(firstB)) || (!isLowerByte(lastB) && !isDigitByte(lastB))) {
|
|
503
|
+
return false;
|
|
504
|
+
}
|
|
505
|
+
let segDigits = 0;
|
|
506
|
+
let segHex = true;
|
|
507
|
+
for (let k = 0; k < segLen; k++) {
|
|
508
|
+
const b = seg[k]!;
|
|
509
|
+
// Strict lowercase [a-z0-9._-] path grammar only
|
|
510
|
+
if (!isLowerByte(b) && !isDigitByte(b) && b !== 0x2e && b !== 0x2d && b !== 0x5f) return false;
|
|
511
|
+
if (isDigitByte(b)) segDigits++;
|
|
512
|
+
if (!isHexByte(b)) segHex = false;
|
|
513
|
+
}
|
|
514
|
+
totalPathDigits += segDigits;
|
|
515
|
+
if (segDigits >= 3) return false;
|
|
516
|
+
if (segHex && segLen >= 8) return false;
|
|
517
|
+
lastSeg = seg;
|
|
518
|
+
segStart = i + 1;
|
|
519
|
+
}
|
|
520
|
+
if (totalPathDigits > 2) return false;
|
|
521
|
+
return lastSeg !== null && isAllowedTerminalUrlSegmentBytes(lastSeg);
|
|
522
|
+
}
|
|
523
|
+
|
|
524
|
+
// kind === "id" or "model"
|
|
525
|
+
const maxLen = kind === "id" ? 48 : 80;
|
|
526
|
+
if (len > maxLen) return false;
|
|
527
|
+
let sepCount = 0;
|
|
528
|
+
let totalDigits = 0;
|
|
529
|
+
for (let i = 0; i < len; i++) {
|
|
530
|
+
const b = slice[i]!;
|
|
531
|
+
const isSep = b === 0x2d || b === 0x5f || b === 0x2e || (kind === "model" && (b === 0x2f || b === 0x3a));
|
|
532
|
+
if (isSep) {
|
|
533
|
+
sepCount++;
|
|
534
|
+
continue;
|
|
535
|
+
}
|
|
536
|
+
if (!isAlphaByte(b) && !isDigitByte(b)) return false;
|
|
537
|
+
if (isDigitByte(b)) totalDigits++;
|
|
538
|
+
}
|
|
539
|
+
if (sepCount === 0 && len >= 16) return false;
|
|
540
|
+
if (kind === "id" && totalDigits > 5) return false;
|
|
541
|
+
|
|
542
|
+
let segStart = 0;
|
|
543
|
+
let mixedDigitsTotal = 0;
|
|
544
|
+
let nonDateDigits = totalDigits;
|
|
545
|
+
let usedDateExemption = false;
|
|
546
|
+
let skipHyphenDateParts = 0;
|
|
547
|
+
let paramSizeSegs = 0;
|
|
548
|
+
for (let i = 0; i <= len; i++) {
|
|
549
|
+
const b = i < len ? slice[i]! : 0x2d;
|
|
550
|
+
const isSep = i === len || b === 0x2d || b === 0x5f || b === 0x2e || b === 0x2f || b === 0x3a;
|
|
551
|
+
if (!isSep) continue;
|
|
552
|
+
const segLen = i - segStart;
|
|
553
|
+
if (segLen > 16) return false;
|
|
554
|
+
if (segLen > 0) {
|
|
555
|
+
let segDigits = 0;
|
|
556
|
+
let segAllDigits = true;
|
|
557
|
+
let segHex = true;
|
|
558
|
+
let hasLower = false;
|
|
559
|
+
let hasUpper = false;
|
|
560
|
+
for (let k = segStart; k < i; k++) {
|
|
561
|
+
const cb = slice[k]!;
|
|
562
|
+
if (isDigitByte(cb)) segDigits++;
|
|
563
|
+
else segAllDigits = false;
|
|
564
|
+
if (!isHexByte(cb)) segHex = false;
|
|
565
|
+
if (isLowerByte(cb)) hasLower = true;
|
|
566
|
+
if (isUpperByte(cb)) hasUpper = true;
|
|
567
|
+
}
|
|
568
|
+
if (segAllDigits) {
|
|
569
|
+
if (skipHyphenDateParts > 0) {
|
|
570
|
+
skipHyphenDateParts--;
|
|
571
|
+
segStart = i + 1;
|
|
572
|
+
continue;
|
|
573
|
+
}
|
|
574
|
+
const isDate8 =
|
|
575
|
+
kind === "model" && !usedDateExemption && segLen === 8
|
|
576
|
+
&& slice[segStart] === 0x32 && slice[segStart + 1] === 0x30
|
|
577
|
+
&& ((slice[segStart + 4]! - 0x30) * 10 + (slice[segStart + 5]! - 0x30)) >= 1
|
|
578
|
+
&& ((slice[segStart + 4]! - 0x30) * 10 + (slice[segStart + 5]! - 0x30)) <= 12
|
|
579
|
+
&& ((slice[segStart + 6]! - 0x30) * 10 + (slice[segStart + 7]! - 0x30)) >= 1
|
|
580
|
+
&& ((slice[segStart + 6]! - 0x30) * 10 + (slice[segStart + 7]! - 0x30)) <= 31;
|
|
581
|
+
const isHyphenDate =
|
|
582
|
+
kind === "model" && !usedDateExemption && segLen === 4
|
|
583
|
+
&& slice[segStart] === 0x32 && slice[segStart + 1] === 0x30
|
|
584
|
+
&& segStart + 10 <= len && slice[segStart + 4] === 0x2d && slice[segStart + 7] === 0x2d
|
|
585
|
+
&& isDigitByte(slice[segStart + 5]!) && isDigitByte(slice[segStart + 6]!)
|
|
586
|
+
&& isDigitByte(slice[segStart + 8]!) && isDigitByte(slice[segStart + 9]!)
|
|
587
|
+
&& ((slice[segStart + 5]! - 0x30) * 10 + (slice[segStart + 6]! - 0x30)) >= 1
|
|
588
|
+
&& ((slice[segStart + 5]! - 0x30) * 10 + (slice[segStart + 6]! - 0x30)) <= 12
|
|
589
|
+
&& ((slice[segStart + 8]! - 0x30) * 10 + (slice[segStart + 9]! - 0x30)) >= 1
|
|
590
|
+
&& ((slice[segStart + 8]! - 0x30) * 10 + (slice[segStart + 9]! - 0x30)) <= 31
|
|
591
|
+
&& (segStart + 10 === len || [0x2d, 0x5f, 0x2e, 0x2f, 0x3a].includes(slice[segStart + 10]!));
|
|
592
|
+
if (isDate8) {
|
|
593
|
+
usedDateExemption = true;
|
|
594
|
+
nonDateDigits -= 8;
|
|
595
|
+
} else if (isHyphenDate) {
|
|
596
|
+
usedDateExemption = true;
|
|
597
|
+
skipHyphenDateParts = 2;
|
|
598
|
+
nonDateDigits -= 8;
|
|
599
|
+
} else if (segLen > 4) {
|
|
600
|
+
return false;
|
|
601
|
+
}
|
|
602
|
+
} else {
|
|
603
|
+
if (kind === "model" && paramSizeSegs < 2 && isModelParamSizeSeg(slice, segStart, i)) {
|
|
604
|
+
paramSizeSegs++;
|
|
605
|
+
nonDateDigits -= segDigits;
|
|
606
|
+
segStart = i + 1;
|
|
607
|
+
continue;
|
|
608
|
+
}
|
|
609
|
+
if (segHex && segLen >= 10) return false;
|
|
610
|
+
if (segDigits >= 4) return false;
|
|
611
|
+
if (segLen >= 10 && hasLower && hasUpper && segDigits >= 1) return false;
|
|
612
|
+
mixedDigitsTotal += segDigits;
|
|
613
|
+
}
|
|
614
|
+
}
|
|
615
|
+
segStart = i + 1;
|
|
616
|
+
}
|
|
617
|
+
if (kind === "model" && nonDateDigits > 8) return false;
|
|
618
|
+
if (mixedDigitsTotal >= 5) return false;
|
|
619
|
+
return true;
|
|
620
|
+
}
|
|
621
|
+
|
|
622
|
+
export function isDisallowedMetadataValue(value: string, kind: MetadataFieldKind): boolean {
|
|
623
|
+
if (value === METADATA_REFUSED_SENTINEL || value === URL_SYNTAX_REFUSED_SENTINEL || hasControlChars(value)) return true;
|
|
624
|
+
const bytes = Buffer.from(value, "utf8");
|
|
625
|
+
try {
|
|
626
|
+
return !isAllowedMetadataBytes(bytes, kind);
|
|
627
|
+
} finally {
|
|
628
|
+
bytes.fill(0);
|
|
629
|
+
}
|
|
630
|
+
}
|
|
631
|
+
|
|
632
|
+
/**
|
|
633
|
+
* Syntax-aware, single-line TOML projection for Codex settings_config.config.
|
|
634
|
+
* Operates on a transient UTF-8 byte buffer (zeroed by the caller in finally) and decodes ONLY:
|
|
635
|
+
* - [table] headers (bare or quoted)
|
|
636
|
+
* - root model, model_provider, base_url, openai_base_url, wire_api
|
|
637
|
+
* - [model_providers.<key>] base_url and wire_api
|
|
638
|
+
* Rejects triple-quoted strings, inline tables, arrays, unclosed quotes, or non-assignment lines.
|
|
639
|
+
*/
|
|
640
|
+
export interface CodexTomlProjection {
|
|
641
|
+
model?: string;
|
|
642
|
+
modelProvider?: string;
|
|
643
|
+
rootBaseUrl?: string;
|
|
644
|
+
rootWireApi?: string;
|
|
645
|
+
providers: Map<string, { baseUrl?: string; wireApi?: string }>;
|
|
646
|
+
}
|
|
647
|
+
|
|
648
|
+
const ALLOWED_TOML_KEYS = ["model", "model_provider", "base_url", "openai_base_url", "wire_api"] as const;
|
|
649
|
+
type AllowedTomlKey = (typeof ALLOWED_TOML_KEYS)[number];
|
|
650
|
+
|
|
651
|
+
function tomlKeyMetadataKind(key: AllowedTomlKey): MetadataFieldKind {
|
|
652
|
+
if (key === "model") return "model";
|
|
653
|
+
if (key === "model_provider") return "id";
|
|
654
|
+
if (key === "wire_api") return "wire";
|
|
655
|
+
return "url";
|
|
656
|
+
}
|
|
657
|
+
|
|
658
|
+
/**
|
|
659
|
+
* Unescape a single-line TOML quoted string slice (without surrounding quotes) into a transient
|
|
660
|
+
* Uint8Array. Caller must zero `out` in finally.
|
|
661
|
+
*/
|
|
662
|
+
export function unescapeTomlStringBytes(
|
|
663
|
+
raw: Uint8Array,
|
|
664
|
+
quoteByte: number,
|
|
665
|
+
): Uint8Array | null {
|
|
666
|
+
const out = new Uint8Array(raw.length);
|
|
667
|
+
let r = 0;
|
|
668
|
+
let w = 0;
|
|
669
|
+
while (r < raw.length) {
|
|
670
|
+
const b = raw[r]!;
|
|
671
|
+
if (b < 0x20 || b === 0x7f) {
|
|
672
|
+
out.fill(0);
|
|
673
|
+
return null;
|
|
674
|
+
}
|
|
675
|
+
if (quoteByte === 0x22 && b === 0x5c) {
|
|
676
|
+
r++;
|
|
677
|
+
if (r >= raw.length) { out.fill(0); return null; }
|
|
678
|
+
const esc = raw[r]!;
|
|
679
|
+
r++;
|
|
680
|
+
if (esc === 0x22 || esc === 0x5c || esc === 0x2f) out[w++] = esc;
|
|
681
|
+
else if (esc === 0x6e || esc === 0x72 || esc === 0x74 || esc === 0x62 || esc === 0x66) {
|
|
682
|
+
out.fill(0);
|
|
683
|
+
return null; // Control escapes are never valid in provider IDs, models, wire APIs, or URLs.
|
|
684
|
+
} else if (esc === 0x75) {
|
|
685
|
+
const cp = parseHex4Bytes(raw, r);
|
|
686
|
+
if (cp <= 0x20 || cp >= 0x7f) { out.fill(0); return null; }
|
|
687
|
+
r += 4;
|
|
688
|
+
w += encodeCodePointUtf8(cp, out, w);
|
|
689
|
+
} else {
|
|
690
|
+
out.fill(0);
|
|
691
|
+
return null;
|
|
692
|
+
}
|
|
693
|
+
continue;
|
|
694
|
+
}
|
|
695
|
+
out[w++] = b;
|
|
696
|
+
r++;
|
|
697
|
+
}
|
|
698
|
+
return out.subarray(0, w);
|
|
699
|
+
}
|
|
700
|
+
|
|
701
|
+
function hasOnlyCommentOrSpaceBytes(slice: Uint8Array, fromIndex: number): boolean {
|
|
702
|
+
let i = fromIndex;
|
|
703
|
+
while (i < slice.length && (slice[i] === 0x20 || slice[i] === 0x09)) i++;
|
|
704
|
+
return i >= slice.length || slice[i] === 0x23;
|
|
705
|
+
}
|
|
706
|
+
|
|
707
|
+
function findQuotedEndInBytes(slice: Uint8Array, quoteStart: number): number {
|
|
708
|
+
const q = slice[quoteStart]!;
|
|
709
|
+
if (q !== 0x22 && q !== 0x27) return -1;
|
|
710
|
+
if (quoteStart + 2 < slice.length && slice[quoteStart + 1] === q && slice[quoteStart + 2] === q) {
|
|
711
|
+
return -1; // Triple-quoted strings are forbidden.
|
|
712
|
+
}
|
|
713
|
+
let i = quoteStart + 1;
|
|
714
|
+
while (i < slice.length) {
|
|
715
|
+
const b = slice[i]!;
|
|
716
|
+
if (b < 0x20 || b === 0x7f) return -1;
|
|
717
|
+
if (q === 0x22 && b === 0x5c) {
|
|
718
|
+
i += 2;
|
|
719
|
+
continue;
|
|
720
|
+
}
|
|
721
|
+
if (b === q) return i;
|
|
722
|
+
i++;
|
|
723
|
+
}
|
|
724
|
+
return -1;
|
|
725
|
+
}
|
|
726
|
+
|
|
727
|
+
function parseTomlHeaderBytes(
|
|
728
|
+
innerRaw: Uint8Array,
|
|
729
|
+
decoder: TextDecoder,
|
|
730
|
+
): { kind: "other" } | { kind: "model_provider"; id: string } | { kind: "error"; reason: CcSwitchInvalidReason } {
|
|
731
|
+
let s = 0;
|
|
732
|
+
let e = innerRaw.length;
|
|
733
|
+
while (s < e && (innerRaw[s] === 0x20 || innerRaw[s] === 0x09)) s++;
|
|
734
|
+
while (e > s && (innerRaw[e - 1] === 0x20 || innerRaw[e - 1] === 0x09)) e--;
|
|
735
|
+
const inner = innerRaw.subarray(s, e);
|
|
736
|
+
if (inner.length === 0) return { kind: "error", reason: "malformed_entry" };
|
|
737
|
+
if (equalsAsciiBytes(inner, "__MULTILINE_REFUSED__") || equalsAsciiBytes(inner, "__MALFORMED_LINE__")) {
|
|
738
|
+
return { kind: "error", reason: "malformed_entry" };
|
|
739
|
+
}
|
|
740
|
+
if (equalsAsciiBytes(inner, METADATA_REFUSED_SENTINEL)) {
|
|
741
|
+
return { kind: "error", reason: "disallowed_metadata" };
|
|
742
|
+
}
|
|
743
|
+
|
|
744
|
+
const segments: Uint8Array[] = [];
|
|
745
|
+
const owned: Uint8Array[] = [];
|
|
746
|
+
try {
|
|
747
|
+
let i = 0;
|
|
748
|
+
while (i < inner.length) {
|
|
749
|
+
while (i < inner.length && (inner[i] === 0x20 || inner[i] === 0x09)) i++;
|
|
750
|
+
if (i >= inner.length) return { kind: "error", reason: "malformed_entry" };
|
|
751
|
+
const b0 = inner[i]!;
|
|
752
|
+
if (b0 === 0x22 || b0 === 0x27) {
|
|
753
|
+
const qEnd = findQuotedEndInBytes(inner, i);
|
|
754
|
+
if (qEnd < 0) return { kind: "error", reason: "malformed_entry" };
|
|
755
|
+
const unesc = unescapeTomlStringBytes(inner.subarray(i + 1, qEnd), b0);
|
|
756
|
+
if (!unesc || unesc.length === 0) return { kind: "error", reason: "malformed_entry" };
|
|
757
|
+
owned.push(unesc);
|
|
758
|
+
segments.push(unesc);
|
|
759
|
+
i = qEnd + 1;
|
|
760
|
+
} else {
|
|
761
|
+
const segStart = i;
|
|
762
|
+
while (i < inner.length) {
|
|
763
|
+
const b = inner[i]!;
|
|
764
|
+
if (isAlphaByte(b) || isDigitByte(b) || b === 0x5f || b === 0x2d) i++;
|
|
765
|
+
else break;
|
|
766
|
+
}
|
|
767
|
+
if (i === segStart) return { kind: "error", reason: "malformed_entry" };
|
|
768
|
+
segments.push(inner.subarray(segStart, i));
|
|
769
|
+
}
|
|
770
|
+
while (i < inner.length && (inner[i] === 0x20 || inner[i] === 0x09)) i++;
|
|
771
|
+
if (i === inner.length) break;
|
|
772
|
+
if (inner[i] === 0x2e) {
|
|
773
|
+
i++;
|
|
774
|
+
if (i >= inner.length) return { kind: "error", reason: "malformed_entry" };
|
|
775
|
+
continue;
|
|
776
|
+
}
|
|
777
|
+
return { kind: "error", reason: "malformed_entry" };
|
|
778
|
+
}
|
|
779
|
+
|
|
780
|
+
if (segments.length === 2 && equalsAsciiBytes(segments[0]!, "model_providers")) {
|
|
781
|
+
const idSlice = segments[1]!;
|
|
782
|
+
if (!isAllowedMetadataBytes(idSlice, "id")) {
|
|
783
|
+
return { kind: "error", reason: "disallowed_metadata" };
|
|
784
|
+
}
|
|
785
|
+
const id = decoder.decode(idSlice);
|
|
786
|
+
return { kind: "model_provider", id };
|
|
787
|
+
}
|
|
788
|
+
return { kind: "other" };
|
|
789
|
+
} catch {
|
|
790
|
+
return { kind: "error", reason: "malformed_entry" };
|
|
791
|
+
} finally {
|
|
792
|
+
for (const buf of owned) buf.fill(0);
|
|
793
|
+
}
|
|
794
|
+
}
|
|
795
|
+
|
|
796
|
+
function classifyTomlKeyBytes(keySlice: Uint8Array): AllowedTomlKey | "other_key" | null {
|
|
797
|
+
const b0 = keySlice[0]!;
|
|
798
|
+
if (b0 === 0x22 || b0 === 0x27) {
|
|
799
|
+
const qEnd = findQuotedEndInBytes(keySlice, 0);
|
|
800
|
+
if (qEnd !== keySlice.length - 1) return null;
|
|
801
|
+
const unesc = unescapeTomlStringBytes(keySlice.subarray(1, qEnd), b0);
|
|
802
|
+
if (!unesc || unesc.length === 0) return null;
|
|
803
|
+
try {
|
|
804
|
+
for (const allowed of ALLOWED_TOML_KEYS) {
|
|
805
|
+
if (equalsAsciiBytes(unesc, allowed)) return allowed;
|
|
806
|
+
}
|
|
807
|
+
return "other_key";
|
|
808
|
+
} finally {
|
|
809
|
+
unesc.fill(0);
|
|
810
|
+
}
|
|
811
|
+
}
|
|
812
|
+
for (let i = 0; i < keySlice.length; i++) {
|
|
813
|
+
const b = keySlice[i]!;
|
|
814
|
+
if (!isAlphaByte(b) && !isDigitByte(b) && b !== 0x5f && b !== 0x2d) return null;
|
|
815
|
+
}
|
|
816
|
+
for (const allowed of ALLOWED_TOML_KEYS) {
|
|
817
|
+
if (equalsAsciiBytes(keySlice, allowed)) return allowed;
|
|
818
|
+
}
|
|
819
|
+
return "other_key";
|
|
820
|
+
}
|
|
821
|
+
|
|
822
|
+
export function parseCodexTomlBytes(bytes: Uint8Array): { ok: true; value: CodexTomlProjection } | { ok: false; reason: CcSwitchInvalidReason } {
|
|
823
|
+
if (bytes.length > MAX_CODEX_TOML_BYTES) return { ok: false, reason: "malformed_entry" };
|
|
824
|
+
const projection: CodexTomlProjection = { providers: new Map() };
|
|
825
|
+
let currentSection: { kind: "root" } | { kind: "model_provider"; id: string } | { kind: "other" } = { kind: "root" };
|
|
826
|
+
const decoder = new TextDecoder("utf-8", { fatal: true });
|
|
827
|
+
let lineStart = 0;
|
|
828
|
+
let lineCount = 0;
|
|
829
|
+
|
|
830
|
+
for (let idx = 0; idx <= bytes.length; idx++) {
|
|
831
|
+
if (idx < bytes.length && bytes[idx] !== 0x0a) continue;
|
|
832
|
+
lineCount++;
|
|
833
|
+
if (lineCount > 501) return { ok: false, reason: "malformed_entry" };
|
|
834
|
+
let lineEnd = idx;
|
|
835
|
+
if (lineEnd > lineStart && bytes[lineEnd - 1] === 0x0d) lineEnd--;
|
|
836
|
+
const slice = bytes.subarray(lineStart, lineEnd);
|
|
837
|
+
lineStart = idx + 1;
|
|
838
|
+
|
|
839
|
+
let p = 0;
|
|
840
|
+
while (p < slice.length && (slice[p] === 0x20 || slice[p] === 0x09)) p++;
|
|
841
|
+
if (p >= slice.length || slice[p] === 0x23) continue;
|
|
842
|
+
if (slice[p] === 0x5b) {
|
|
843
|
+
// Scan and classify table headers in raw bytes so neither trailing comments nor unvalidated/unrelated headers are decoded.
|
|
844
|
+
if (p + 1 < slice.length && slice[p + 1] === 0x5b) return { ok: false, reason: "malformed_entry" };
|
|
845
|
+
let closeB = -1;
|
|
846
|
+
let inQ = 0;
|
|
847
|
+
for (let k = p + 1; k < slice.length; k++) {
|
|
848
|
+
const b = slice[k]!;
|
|
849
|
+
if (inQ === 0 && b === 0x23) break;
|
|
850
|
+
if (inQ === 0 && (b === 0x22 || b === 0x27)) { inQ = b; continue; }
|
|
851
|
+
if (inQ === 0x22 && b === 0x5c) { k++; continue; }
|
|
852
|
+
if (inQ !== 0 && b === inQ) { inQ = 0; continue; }
|
|
853
|
+
if (inQ === 0 && b === 0x5d) { closeB = k; break; }
|
|
854
|
+
}
|
|
855
|
+
if (closeB < 0 || !hasOnlyCommentOrSpaceBytes(slice, closeB + 1)) {
|
|
856
|
+
return { ok: false, reason: "malformed_entry" };
|
|
857
|
+
}
|
|
858
|
+
const header = parseTomlHeaderBytes(slice.subarray(p + 1, closeB), decoder);
|
|
859
|
+
if (header.kind === "error") return { ok: false, reason: header.reason };
|
|
860
|
+
currentSection = header;
|
|
861
|
+
continue;
|
|
862
|
+
}
|
|
863
|
+
|
|
864
|
+
let eq = -1;
|
|
865
|
+
let inKeyQuote = 0;
|
|
866
|
+
for (let k = p; k < slice.length; k++) {
|
|
867
|
+
const b = slice[k]!;
|
|
868
|
+
if (inKeyQuote === 0 && b === 0x23) break;
|
|
869
|
+
if (inKeyQuote === 0 && (b === 0x22 || b === 0x27)) { inKeyQuote = b; continue; }
|
|
870
|
+
if (inKeyQuote !== 0 && b === 0x5c && inKeyQuote === 0x22) { k++; continue; }
|
|
871
|
+
if (inKeyQuote !== 0 && b === inKeyQuote) { inKeyQuote = 0; continue; }
|
|
872
|
+
if (inKeyQuote === 0 && b === 0x3d) { eq = k; break; }
|
|
873
|
+
}
|
|
874
|
+
if (eq < 0) return { ok: false, reason: "malformed_entry" };
|
|
875
|
+
let kStart = p;
|
|
876
|
+
let kEnd = eq;
|
|
877
|
+
while (kStart < kEnd && (slice[kStart] === 0x20 || slice[kStart] === 0x09)) kStart++;
|
|
878
|
+
while (kEnd > kStart && (slice[kEnd - 1] === 0x20 || slice[kEnd - 1] === 0x09)) kEnd--;
|
|
879
|
+
if (kEnd - kStart <= 0 || kEnd - kStart > 128) return { ok: false, reason: "malformed_entry" };
|
|
880
|
+
|
|
881
|
+
const classifiedKey = classifyTomlKeyBytes(slice.subarray(kStart, kEnd));
|
|
882
|
+
if (classifiedKey === null) return { ok: false, reason: "malformed_entry" };
|
|
883
|
+
|
|
884
|
+
let vStart = eq + 1;
|
|
885
|
+
while (vStart < slice.length && (slice[vStart] === 0x20 || slice[vStart] === 0x09)) vStart++;
|
|
886
|
+
if (vStart >= slice.length) return { ok: false, reason: "malformed_entry" };
|
|
887
|
+
if (
|
|
888
|
+
vStart + 2 < slice.length
|
|
889
|
+
&& ((slice[vStart] === 0x22 && slice[vStart + 1] === 0x22 && slice[vStart + 2] === 0x22)
|
|
890
|
+
|| (slice[vStart] === 0x27 && slice[vStart + 1] === 0x27 && slice[vStart + 2] === 0x27))
|
|
891
|
+
) {
|
|
892
|
+
return { ok: false, reason: "malformed_entry" };
|
|
893
|
+
}
|
|
894
|
+
|
|
895
|
+
const relevant =
|
|
896
|
+
classifiedKey !== "other_key"
|
|
897
|
+
&& (
|
|
898
|
+
currentSection.kind === "root"
|
|
899
|
+
|| (currentSection.kind === "model_provider" && (classifiedKey === "base_url" || classifiedKey === "wire_api"))
|
|
900
|
+
);
|
|
901
|
+
if (!relevant) {
|
|
902
|
+
let q = 0;
|
|
903
|
+
let depth = 0;
|
|
904
|
+
for (let k = vStart; k < slice.length; k++) {
|
|
905
|
+
const b = slice[k]!;
|
|
906
|
+
if (q === 0 && b === 0x23) break;
|
|
907
|
+
if (q === 0 && (b === 0x22 || b === 0x27)) { q = b; continue; }
|
|
908
|
+
if (q !== 0 && b === 0x5c && q === 0x22) { k++; continue; }
|
|
909
|
+
if (q !== 0 && b === q) { q = 0; continue; }
|
|
910
|
+
if (q === 0 && (b === 0x5b || b === 0x7b)) depth++;
|
|
911
|
+
if (q === 0 && (b === 0x5d || b === 0x7d)) {
|
|
912
|
+
depth--;
|
|
913
|
+
if (depth < 0) return { ok: false, reason: "malformed_entry" };
|
|
914
|
+
}
|
|
915
|
+
}
|
|
916
|
+
if (q !== 0 || depth !== 0) return { ok: false, reason: "malformed_entry" };
|
|
917
|
+
continue;
|
|
918
|
+
}
|
|
919
|
+
|
|
920
|
+
// Scan the quoted value in raw bytes so trailing '# comment' is never decoded!
|
|
921
|
+
const vEnd = findQuotedEndInBytes(slice, vStart);
|
|
922
|
+
if (vEnd < 0 || !hasOnlyCommentOrSpaceBytes(slice, vEnd + 1)) {
|
|
923
|
+
return { ok: false, reason: "malformed_entry" };
|
|
924
|
+
}
|
|
925
|
+
const key: AllowedTomlKey = classifiedKey as AllowedTomlKey;
|
|
926
|
+
const unescaped = unescapeTomlStringBytes(slice.subarray(vStart + 1, vEnd), slice[vStart]!);
|
|
927
|
+
if (!unescaped || unescaped.length === 0) return { ok: false, reason: "malformed_entry" };
|
|
928
|
+
let value: string;
|
|
929
|
+
try {
|
|
930
|
+
const metaKind = tomlKeyMetadataKind(key);
|
|
931
|
+
if (metaKind === "url" && equalsAsciiBytes(unescaped, URL_SYNTAX_REFUSED_SENTINEL)) {
|
|
932
|
+
return { ok: false, reason: "invalid_base_url" };
|
|
933
|
+
}
|
|
934
|
+
if (equalsAsciiBytes(unescaped, METADATA_REFUSED_SENTINEL)) {
|
|
935
|
+
return { ok: false, reason: "disallowed_metadata" };
|
|
936
|
+
}
|
|
937
|
+
if (!isAllowedMetadataBytes(unescaped, metaKind)) {
|
|
938
|
+
return { ok: false, reason: metaKind === "url" ? "invalid_base_url" : "disallowed_metadata" };
|
|
939
|
+
}
|
|
940
|
+
value = decoder.decode(unescaped);
|
|
941
|
+
if (value === URL_SYNTAX_REFUSED_SENTINEL) return { ok: false, reason: "invalid_base_url" };
|
|
942
|
+
if (value === METADATA_REFUSED_SENTINEL) return { ok: false, reason: "disallowed_metadata" };
|
|
943
|
+
} catch {
|
|
944
|
+
return { ok: false, reason: "malformed_entry" };
|
|
945
|
+
} finally {
|
|
946
|
+
unescaped.fill(0);
|
|
947
|
+
}
|
|
948
|
+
|
|
949
|
+
if (currentSection.kind === "root") {
|
|
950
|
+
if (key === "model") projection.model = value;
|
|
951
|
+
else if (key === "model_provider") projection.modelProvider = value;
|
|
952
|
+
else if (key === "base_url" || key === "openai_base_url") projection.rootBaseUrl = value;
|
|
953
|
+
else if (key === "wire_api") projection.rootWireApi = value;
|
|
954
|
+
} else if (currentSection.kind === "model_provider") {
|
|
955
|
+
const entry = projection.providers.get(currentSection.id) ?? {};
|
|
956
|
+
if (key === "base_url") entry.baseUrl = value;
|
|
957
|
+
else if (key === "wire_api") entry.wireApi = value;
|
|
958
|
+
projection.providers.set(currentSection.id, entry);
|
|
959
|
+
}
|
|
960
|
+
}
|
|
961
|
+
|
|
962
|
+
return { ok: true, value: projection };
|
|
963
|
+
}
|
|
964
|
+
|
|
965
|
+
export function resolveCodexProjection(proj: CodexTomlProjection): { ok: true; baseUrl: string; wireApi: string; defaultModel?: string } | { ok: false; reason: CcSwitchInvalidReason } {
|
|
966
|
+
let baseUrl: string | undefined;
|
|
967
|
+
let wireApi = proj.rootWireApi ?? "responses";
|
|
968
|
+
if (proj.modelProvider !== undefined) {
|
|
969
|
+
const selected = proj.providers.get(proj.modelProvider);
|
|
970
|
+
if (!selected?.baseUrl) return { ok: false, reason: "missing_base_url" };
|
|
971
|
+
baseUrl = selected.baseUrl;
|
|
972
|
+
if (selected.wireApi) wireApi = selected.wireApi;
|
|
973
|
+
} else if (proj.providers.size > 1) {
|
|
974
|
+
return { ok: false, reason: "ambiguous_codex_provider" };
|
|
975
|
+
} else if (proj.providers.size === 1) {
|
|
976
|
+
const only = [...proj.providers.values()][0]!;
|
|
977
|
+
if (!only.baseUrl) return { ok: false, reason: "missing_base_url" };
|
|
978
|
+
baseUrl = only.baseUrl;
|
|
979
|
+
if (only.wireApi) wireApi = only.wireApi;
|
|
980
|
+
} else if (proj.rootBaseUrl) {
|
|
981
|
+
baseUrl = proj.rootBaseUrl;
|
|
982
|
+
} else {
|
|
983
|
+
return { ok: false, reason: "missing_base_url" };
|
|
984
|
+
}
|
|
985
|
+
return {
|
|
986
|
+
ok: true,
|
|
987
|
+
baseUrl,
|
|
988
|
+
wireApi,
|
|
989
|
+
...(proj.model ? { defaultModel: proj.model } : {}),
|
|
990
|
+
};
|
|
991
|
+
}
|