crysk 0.5.1 → 0.6.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (67) hide show
  1. package/README.md +15 -1
  2. package/dist/SKILL-nncgwkx7.md +553 -0
  3. package/dist/cli.js +6379 -5561
  4. package/dist/index.js +967 -467
  5. package/dist/workflow-ag62s87j.yml +163 -0
  6. package/package.json +3 -2
  7. package/skills/crysk-ci-setup/assets/workflow.yml +3 -0
  8. package/skills/crysk-loop/SKILL.md +2 -2
  9. package/src/asset-manifest.ts +11 -0
  10. package/src/assets.ts +34 -11
  11. package/src/ci/credential-refresh.ts +524 -0
  12. package/src/ci/crysk-secrets.ts +20 -6
  13. package/src/ci/gates.ts +2 -24
  14. package/src/ci/outcome.ts +165 -15
  15. package/src/ci/platform.ts +205 -7
  16. package/src/ci/setup.ts +64 -6
  17. package/src/ci/trigger.ts +84 -8
  18. package/src/commands/ci-setup.ts +12 -3
  19. package/src/commands/doctor.ts +25 -23
  20. package/src/commands/status.ts +2 -0
  21. package/src/diversity/identity.ts +11 -1
  22. package/src/diversity/pipeline-integration.ts +19 -6
  23. package/src/doctor.ts +133 -4
  24. package/src/execution/contracts.ts +15 -3
  25. package/src/harness/materiality-judge.ts +153 -0
  26. package/src/harness/pipeline-plan.ts +133 -0
  27. package/src/harness/replay-rows.ts +172 -0
  28. package/src/harness/route-runner.ts +288 -0
  29. package/src/harness/single-step.ts +153 -0
  30. package/src/index.ts +1 -1
  31. package/src/model/catalog.ts +10 -7
  32. package/src/model/model-name.ts +14 -0
  33. package/src/model/profiles/claude.ts +34 -0
  34. package/src/model/profiles/openai.ts +44 -0
  35. package/src/model/profiles.ts +213 -0
  36. package/src/model/routing.ts +155 -50
  37. package/src/pr/answered-findings.ts +3 -0
  38. package/src/pr/ci-admission-gate.ts +1 -0
  39. package/src/pr/discovery.ts +1 -0
  40. package/src/pr/plan.ts +6 -1
  41. package/src/pr/pr-status.ts +18 -3
  42. package/src/pr/publish-outcome.ts +14 -13
  43. package/src/pr/review-pr.ts +49 -8
  44. package/src/pr/target.ts +16 -7
  45. package/src/production-runtime.ts +100 -13
  46. package/src/rereview/prepare.ts +13 -2
  47. package/src/review/exit-code.ts +60 -0
  48. package/src/review/findings.ts +3 -3
  49. package/src/review/pipeline.ts +193 -58
  50. package/src/review/preflight.ts +100 -10
  51. package/src/review/prompt-set.ts +73 -0
  52. package/src/review/review.ts +32 -13
  53. package/src/review/route-preflight.ts +117 -67
  54. package/src/review/run.ts +34 -4
  55. package/src/security/credential-broker.ts +21 -9
  56. package/src/security/oauth-providers.ts +101 -0
  57. package/src/transport-registry.ts +33 -0
  58. package/src/transports/opencode-sdk.ts +33 -1
  59. package/src/triage/adjudication.ts +35 -2
  60. package/src/ui/config-edit.ts +9 -0
  61. package/src/ui/config.ts +1 -0
  62. package/src/ui/menu.ts +9 -2
  63. package/src/ui/result.ts +1 -1
  64. package/src/updater.ts +21 -13
  65. package/src/watch/preflight.ts +34 -8
  66. package/src/watch/watch.ts +8 -4
  67. package/src/wizard.ts +23 -0
@@ -0,0 +1,524 @@
1
+ // The action's credential refresh step (cryskai/platform odd/tasks/openai-oauth.md,
2
+ // E3): renews an OpenCode subscription login on the customer's runner, seals the
3
+ // new record with the target's GitHub public key, and hands the platform only
4
+ // the ciphertext, which it writes back as the same CRYSK_OPENCODE_<P>_OAUTH
5
+ // secret.
6
+ //
7
+ // It runs only when the platform dispatched the workflow with
8
+ // `operation: refresh-credential` (action.yml), after the connect step and
9
+ // `bun install`. A review never renews a rotating login (E1): the refresh token
10
+ // rotates on use and a reused one is refused for good, so this step is the one
11
+ // serialized place where the chain moves.
12
+ //
13
+ // The order is the contract with the platform (CREDENTIAL_REFRESH_PATHS):
14
+ // 1. `targets`: the public key of the secret's target. Everything that can fail
15
+ // on the runner (provider, record, key) is checked before step 2, so a
16
+ // failure there spends nothing and the platform may dispatch again.
17
+ // 2. `begin`: the platform records that the stored refresh token is about to
18
+ // be spent. Then ONE POST to the provider's token endpoint, never retried:
19
+ // a request that may have reached the provider may have spent the token.
20
+ // 3. `result`: the sealed record, or `{failure}`. Once the provider answered
21
+ // with new tokens the stored refresh token is spent, so the sealed record
22
+ // is kept in memory and this POST is retried for minutes before giving up.
23
+ //
24
+ // WHY nothing is written: no file, no step output. Every token is masked with
25
+ // `::add-mask::` before anything else is printed, and every message goes through
26
+ // `redact`, so no value reaches the log even when a request fails.
27
+ //
28
+ // The provider's behavior (token URL, client id, permanent errors, account id)
29
+ // is data in src/security/oauth-providers.ts; this script never names a provider.
30
+
31
+ import {
32
+ type OAuthProviderDescriptor,
33
+ oauthProvider,
34
+ } from "../security/oauth-providers";
35
+ import {
36
+ type OpenCodeOAuthRecord,
37
+ opencodeSecretsFor,
38
+ opencodeSecretToken,
39
+ parseCryskSecrets,
40
+ } from "./crysk-secrets";
41
+ import { PLATFORM_API_URL } from "./platform";
42
+
43
+ // ---------------------------------------------------------------------------
44
+ // The platform contract. The Crysk platform implements the same three
45
+ // endpoints (docs/github-actions.md, "Subscription logins"). Every request is a
46
+ // JSON POST with `Authorization: Bearer <run token>` (the connect step's) and
47
+ // `X-Crysk-Dispatch-Id: <dispatch id>` (the workflow_dispatch input).
48
+ // ---------------------------------------------------------------------------
49
+
50
+ export const CREDENTIAL_REFRESH_PATHS = {
51
+ targets: "/runs/credential-refresh/targets",
52
+ begin: "/runs/credential-refresh/begin",
53
+ result: "/runs/credential-refresh",
54
+ } as const;
55
+
56
+ // `targets` and `begin` carry only the provider; the platform checks it against
57
+ // the refresh it dispatched.
58
+ export interface CredentialRefreshProviderBody {
59
+ provider: string;
60
+ }
61
+
62
+ // `targets` answers the GitHub public key of the secret's target (the
63
+ // organization or the repository), as GitHub's `.../secrets/public-key` does.
64
+ export interface CredentialRefreshTargetsReply {
65
+ key_id: string;
66
+ key: string;
67
+ }
68
+
69
+ export type CredentialRefreshResultBody =
70
+ | {
71
+ provider: string;
72
+ key_id: string;
73
+ // Standard padded base64 of the libsodium sealed box, as GitHub's
74
+ // "create or update a secret" API takes it. The sealed plaintext is the
75
+ // secret's value: standard base64 of the record's JSON, as
76
+ // CRYSK_OPENCODE_<P>_OAUTH stores it.
77
+ encrypted_value: string;
78
+ // ISO 8601, UTC. When the provider issued the new access token (the
79
+ // runner's clock at its answer) and when the record says it expires.
80
+ issued_at: string;
81
+ expires_at: string;
82
+ // The provider's account id (ChatGPT's account for OpenAI), or null.
83
+ provider_account_id: string | null;
84
+ }
85
+ | {
86
+ provider: string;
87
+ // One of the descriptor's permanent error codes (log in again), or
88
+ // PROVIDER_ERROR_FAILURE.
89
+ failure: string;
90
+ };
91
+
92
+ // The provider answered with an error that is not one of its permanent codes
93
+ // (a 5xx, a 429, an unknown code, or a 200 without an access token). Whether the
94
+ // stored refresh token survived is unknown; the platform decides what follows.
95
+ export const PROVIDER_ERROR_FAILURE = "provider_error";
96
+
97
+ // The result POST is retried on a transport failure, a 5xx or a 429, with this
98
+ // backoff, for at most RESULT_RETRY_BUDGET_MS. The worst case for the step is
99
+ // that budget plus one request timeout; the platform's lease must outlast it.
100
+ export const RESULT_RETRY_BUDGET_MS = 10 * 60 * 1000;
101
+ const RESULT_RETRY_FIRST_DELAY_MS = 5_000;
102
+ const RESULT_RETRY_MAX_DELAY_MS = 60_000;
103
+ const REQUEST_TIMEOUT_MS = 30_000;
104
+ // OpenCode's own fallback when the token response states no `expires_in`.
105
+ const DEFAULT_EXPIRES_IN_S = 3600;
106
+ // The longest lifetime believed from a provider's answer. OpenAI's tokens live
107
+ // 240 hours; a stated expiry past a year is a malformed answer, and one past what
108
+ // Date can print would throw after the stored refresh token was spent.
109
+ const MAX_EXPIRES_IN_MS = 366 * 24 * 60 * 60 * 1000;
110
+
111
+ export const REFRESH_OPERATION = "refresh-credential";
112
+
113
+ export type Sealer = (value: string) => string;
114
+
115
+ // Loads libsodium and returns a sealer for one GitHub public key, or throws when
116
+ // the key is not a 32-byte X25519 key in standard base64. Loaded lazily, here
117
+ // only, so no other step's import closure gains the package.
118
+ export async function githubSealer(publicKeyBase64: string): Promise<Sealer> {
119
+ const { default: sodium } = await import("libsodium-wrappers");
120
+ await sodium.ready;
121
+ let key: Uint8Array;
122
+ try {
123
+ key = sodium.from_base64(publicKeyBase64, sodium.base64_variants.ORIGINAL);
124
+ } catch {
125
+ throw new Error("the target's public key is not base64");
126
+ }
127
+ if (key.length !== sodium.crypto_box_PUBLICKEYBYTES) {
128
+ throw new Error("the target's public key is not the expected size");
129
+ }
130
+ return (value) =>
131
+ sodium.to_base64(
132
+ sodium.crypto_box_seal(sodium.from_string(value), key),
133
+ sodium.base64_variants.ORIGINAL,
134
+ );
135
+ }
136
+
137
+ export interface CredentialRefreshDeps {
138
+ fetch: typeof fetch;
139
+ env: Readonly<Record<string, string | undefined>>;
140
+ // The crysk-secrets input, read from stdin by the entry point.
141
+ cryskSecrets: string;
142
+ baseUrl: string;
143
+ stdout: (text: string) => void;
144
+ now: () => number;
145
+ sleep: (ms: number) => Promise<void>;
146
+ }
147
+
148
+ function escapeCommandData(text: string): string {
149
+ return text.replace(/%/g, "%25").replace(/\r/g, "%0D").replace(/\n/g, "%0A");
150
+ }
151
+
152
+ function isPlainObject(value: unknown): value is Record<string, unknown> {
153
+ return typeof value === "object" && value !== null && !Array.isArray(value);
154
+ }
155
+
156
+ // The JWT payload's claims, or undefined when the token is not a JWT.
157
+ function jwtClaims(token: unknown): Record<string, unknown> | undefined {
158
+ if (typeof token !== "string") return undefined;
159
+ const parts = token.split(".");
160
+ if (parts.length !== 3) return undefined;
161
+ try {
162
+ const claims: unknown = JSON.parse(
163
+ Buffer.from(parts[1] as string, "base64url").toString("utf8"),
164
+ );
165
+ return isPlainObject(claims) ? claims : undefined;
166
+ } catch {
167
+ return undefined;
168
+ }
169
+ }
170
+
171
+ function claimAt(
172
+ claims: unknown,
173
+ pathParts: readonly (string | number)[],
174
+ ): unknown {
175
+ let value: unknown = claims;
176
+ for (const part of pathParts) {
177
+ if (typeof part === "number") {
178
+ if (!Array.isArray(value)) return undefined;
179
+ value = value[part];
180
+ } else {
181
+ if (!isPlainObject(value)) return undefined;
182
+ value = value[part];
183
+ }
184
+ }
185
+ return value;
186
+ }
187
+
188
+ // The account id the descriptor says where to find: the first claim path that
189
+ // holds a non-empty string in the first token that has one, else the stored
190
+ // record's field (OpenCode's order: extractAccountId, then the record's).
191
+ export function accountIdFor(
192
+ descriptor: OAuthProviderDescriptor,
193
+ tokens: Record<string, unknown>,
194
+ record: OpenCodeOAuthRecord,
195
+ ): string | undefined {
196
+ const source = descriptor.accountId;
197
+ if (source === undefined) return undefined;
198
+ for (const tokenName of source.tokens) {
199
+ const claims = jwtClaims(tokens[tokenName]);
200
+ if (claims === undefined) continue;
201
+ for (const claimPath of source.claims) {
202
+ const value = claimAt(claims, claimPath);
203
+ if (typeof value === "string" && value !== "") return value;
204
+ }
205
+ }
206
+ const kept = record[source.recordField];
207
+ return typeof kept === "string" && kept !== "" ? kept : undefined;
208
+ }
209
+
210
+ // The error code in a token endpoint's error body: RFC 6749's string `error`,
211
+ // OpenAI's `error.code`, or a top-level `code`.
212
+ export function providerErrorCode(body: unknown): string | undefined {
213
+ if (!isPlainObject(body)) return undefined;
214
+ const { error, code } = body;
215
+ if (typeof error === "string" && error !== "") return error;
216
+ if (isPlainObject(error) && typeof error.code === "string" && error.code) {
217
+ return error.code;
218
+ }
219
+ return typeof code === "string" && code !== "" ? code : undefined;
220
+ }
221
+
222
+ export async function runCredentialRefresh(
223
+ deps: CredentialRefreshDeps,
224
+ ): Promise<number> {
225
+ const secrets: string[] = [];
226
+ const redact = (text: string): string => {
227
+ let safe = text;
228
+ // Longest first, so a secret that contains another is hidden whole.
229
+ for (const secret of [...secrets].sort((a, b) => b.length - a.length)) {
230
+ if (secret !== "") safe = safe.split(secret).join("***");
231
+ }
232
+ return safe;
233
+ };
234
+ const mask = (value: string): void => {
235
+ if (value.length < 4 || secrets.includes(value)) return;
236
+ secrets.push(value);
237
+ deps.stdout(`::add-mask::${escapeCommandData(value)}\n`);
238
+ };
239
+ const fail = (message: string): number => {
240
+ deps.stdout(
241
+ `::error title=crysk::${escapeCommandData(redact(`Crysk credential refresh failed: ${message}`))}\n`,
242
+ );
243
+ return 1;
244
+ };
245
+
246
+ const operation = deps.env.CRYSK_OPERATION ?? "";
247
+ if (operation !== REFRESH_OPERATION) {
248
+ return fail(
249
+ `the operation input is "${operation}", which is neither "review" (the default) nor "${REFRESH_OPERATION}".`,
250
+ );
251
+ }
252
+ const providerId = deps.env.CRYSK_REFRESH_PROVIDER ?? "";
253
+ const descriptor = oauthProvider(providerId);
254
+ const token = opencodeSecretToken(providerId);
255
+ if (descriptor === undefined || token === undefined) {
256
+ return fail(
257
+ `the refresh-provider input "${providerId}" is not a subscription provider Crysk can renew.`,
258
+ );
259
+ }
260
+ const secretName = `CRYSK_OPENCODE_${token}_OAUTH`;
261
+ const runToken = deps.env.CRYSK_RUN_TOKEN ?? "";
262
+ const dispatchId = deps.env.CRYSK_DISPATCH_ID ?? "";
263
+ if (runToken === "" || dispatchId === "") {
264
+ return fail(
265
+ "no Crysk run token or dispatch id reached this step; a refresh runs only when the Crysk platform dispatches it.",
266
+ );
267
+ }
268
+ mask(runToken);
269
+
270
+ const parse = parseCryskSecrets(deps.cryskSecrets);
271
+ for (const value of parse.masks) mask(value);
272
+ const problem = parse.problems.find((text) => text.startsWith(secretName));
273
+ if (problem !== undefined) return fail(`${problem}.`);
274
+ const record = opencodeSecretsFor(parse.secrets, providerId)?.oauth;
275
+ if (record === undefined) {
276
+ return fail(
277
+ `${secretName} is not set in the crysk-secrets input; connect the subscription again from the Crysk dashboard.`,
278
+ );
279
+ }
280
+ const storedRefresh = record.refresh;
281
+ if (typeof storedRefresh !== "string" || storedRefresh === "") {
282
+ return fail(
283
+ `${secretName} holds no refresh token; connect the subscription again from the Crysk dashboard.`,
284
+ );
285
+ }
286
+
287
+ const post = async (
288
+ endpoint: string,
289
+ body: unknown,
290
+ ): Promise<{ ok: true; reply: unknown } | { ok: false; status?: number }> => {
291
+ try {
292
+ const response = await deps.fetch(`${deps.baseUrl}${endpoint}`, {
293
+ method: "POST",
294
+ headers: {
295
+ Authorization: `Bearer ${runToken}`,
296
+ "X-Crysk-Dispatch-Id": dispatchId,
297
+ "Content-Type": "application/json",
298
+ },
299
+ body: JSON.stringify(body),
300
+ signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS),
301
+ });
302
+ if (!response.ok) return { ok: false, status: response.status };
303
+ return { ok: true, reply: await response.json().catch(() => ({})) };
304
+ } catch {
305
+ return { ok: false };
306
+ }
307
+ };
308
+ const describe = (status: number | undefined): string =>
309
+ status === undefined ? "the request could not complete" : `HTTP ${status}`;
310
+
311
+ // Retried while the platform may still take it (a transport failure, a 5xx, a
312
+ // 429); any other 4xx is a refusal and retrying cannot change it.
313
+ const postResult = async (
314
+ body: CredentialRefreshResultBody,
315
+ ): Promise<{ ok: true } | { ok: false; status?: number }> => {
316
+ const deadline = deps.now() + RESULT_RETRY_BUDGET_MS;
317
+ let delay = RESULT_RETRY_FIRST_DELAY_MS;
318
+ for (;;) {
319
+ const sent = await post(CREDENTIAL_REFRESH_PATHS.result, body);
320
+ if (sent.ok) return { ok: true };
321
+ const retryable =
322
+ sent.status === undefined || sent.status >= 500 || sent.status === 429;
323
+ if (!retryable || deps.now() + delay > deadline) return sent;
324
+ await deps.sleep(delay);
325
+ delay = Math.min(delay * 2, RESULT_RETRY_MAX_DELAY_MS);
326
+ }
327
+ };
328
+ const reportFailure = async (
329
+ failure: string,
330
+ message: string,
331
+ ): Promise<number> => {
332
+ const sent = await postResult({ provider: providerId, failure });
333
+ return fail(
334
+ sent.ok
335
+ ? message
336
+ : `${message} The platform was not told (${describe(sent.status)}).`,
337
+ );
338
+ };
339
+
340
+ // 1. The target's public key, and the sealer for it, before anything is spent.
341
+ const targets = await post(CREDENTIAL_REFRESH_PATHS.targets, {
342
+ provider: providerId,
343
+ } satisfies CredentialRefreshProviderBody);
344
+ if (!targets.ok) {
345
+ return fail(
346
+ `the Crysk platform did not answer the refresh target (${describe(targets.status)}); nothing was spent.`,
347
+ );
348
+ }
349
+ const target = targets.reply;
350
+ if (
351
+ !isPlainObject(target) ||
352
+ typeof target.key_id !== "string" ||
353
+ target.key_id === "" ||
354
+ typeof target.key !== "string"
355
+ ) {
356
+ return fail(
357
+ "the Crysk platform answered the refresh target without a key_id and key; nothing was spent.",
358
+ );
359
+ }
360
+ const keyId = target.key_id;
361
+ let seal: Sealer;
362
+ try {
363
+ seal = await githubSealer(target.key);
364
+ } catch (error) {
365
+ const detail = error instanceof Error ? error.message : String(error);
366
+ return fail(`${detail}; nothing was spent.`);
367
+ }
368
+
369
+ // 2. The platform records the spend, then one request to the provider.
370
+ const begun = await post(CREDENTIAL_REFRESH_PATHS.begin, {
371
+ provider: providerId,
372
+ } satisfies CredentialRefreshProviderBody);
373
+ if (!begun.ok) {
374
+ return fail(
375
+ `the Crysk platform did not start the refresh (${describe(begun.status)}); nothing was spent.`,
376
+ );
377
+ }
378
+
379
+ let response: Response;
380
+ try {
381
+ response = await deps.fetch(descriptor.refresh.tokenUrl, {
382
+ method: "POST",
383
+ headers: { "Content-Type": "application/x-www-form-urlencoded" },
384
+ body: new URLSearchParams({
385
+ ...descriptor.refresh.extraParams,
386
+ grant_type: "refresh_token",
387
+ refresh_token: storedRefresh,
388
+ client_id: descriptor.refresh.clientId,
389
+ }).toString(),
390
+ signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS),
391
+ });
392
+ } catch {
393
+ // Not retried and not reported: the request may have reached the provider
394
+ // and spent the stored token, so only the platform's own rule may follow.
395
+ return fail(
396
+ `the ${providerId} token endpoint could not be reached; the stored login may have been spent.`,
397
+ );
398
+ }
399
+ let tokens: unknown;
400
+ try {
401
+ tokens = await response.json();
402
+ } catch {
403
+ tokens = undefined;
404
+ }
405
+ // Every token is masked before any other write, whatever the answer looks
406
+ // like (`access_token`, `refresh_token`, `id_token`; not `token_type`, whose
407
+ // `Bearer` would blank ordinary text across the log).
408
+ if (isPlainObject(tokens)) {
409
+ for (const [key, value] of Object.entries(tokens)) {
410
+ if (key.endsWith("token") && typeof value === "string") mask(value);
411
+ }
412
+ }
413
+ if (!response.ok) {
414
+ const code = providerErrorCode(tokens);
415
+ if (code !== undefined && descriptor.permanentErrors.includes(code)) {
416
+ return reportFailure(
417
+ code,
418
+ `${providerId} refused the stored login (${code}); connect the subscription again from the Crysk dashboard.`,
419
+ );
420
+ }
421
+ return reportFailure(
422
+ PROVIDER_ERROR_FAILURE,
423
+ `the ${providerId} token endpoint answered HTTP ${response.status}.`,
424
+ );
425
+ }
426
+ if (
427
+ !isPlainObject(tokens) ||
428
+ typeof tokens.access_token !== "string" ||
429
+ tokens.access_token === ""
430
+ ) {
431
+ return reportFailure(
432
+ PROVIDER_ERROR_FAILURE,
433
+ `the ${providerId} token endpoint answered without an access token.`,
434
+ );
435
+ }
436
+
437
+ // 3. From here the stored refresh token is spent: nothing may stop the
438
+ // result POST. The record is OpenCode's own shape after a refresh.
439
+ const issuedAt = deps.now();
440
+ const access = tokens.access_token;
441
+ const refresh =
442
+ typeof tokens.refresh_token === "string" && tokens.refresh_token !== ""
443
+ ? tokens.refresh_token
444
+ : storedRefresh;
445
+ const expiresIn = tokens.expires_in;
446
+ const jwtExp = jwtClaims(access)?.exp;
447
+ const believable = (at: number) =>
448
+ Number.isFinite(at) && at > issuedAt && at <= issuedAt + MAX_EXPIRES_IN_MS;
449
+ const fromAnswer =
450
+ typeof expiresIn === "number" ? issuedAt + expiresIn * 1000 : Number.NaN;
451
+ const fromJwt = typeof jwtExp === "number" ? jwtExp * 1000 : Number.NaN;
452
+ const expires = believable(fromAnswer)
453
+ ? fromAnswer
454
+ : believable(fromJwt)
455
+ ? fromJwt
456
+ : issuedAt + DEFAULT_EXPIRES_IN_S * 1000;
457
+ const accountId = accountIdFor(descriptor, tokens, record);
458
+ const recordField = descriptor.accountId?.recordField;
459
+ const renewed: Record<string, unknown> = {
460
+ type: "oauth",
461
+ refresh,
462
+ access,
463
+ expires,
464
+ ...(accountId !== undefined && recordField !== undefined
465
+ ? { [recordField]: accountId }
466
+ : {}),
467
+ };
468
+ const value = Buffer.from(JSON.stringify(renewed), "utf8").toString("base64");
469
+ mask(value);
470
+ let encrypted: string;
471
+ try {
472
+ encrypted = seal(value);
473
+ } catch (error) {
474
+ const detail = error instanceof Error ? error.message : String(error);
475
+ return fail(
476
+ `the renewed login could not be sealed (${detail}); the stored login was spent.`,
477
+ );
478
+ }
479
+ const sent = await postResult({
480
+ provider: providerId,
481
+ key_id: keyId,
482
+ encrypted_value: encrypted,
483
+ issued_at: new Date(issuedAt).toISOString(),
484
+ expires_at: new Date(expires).toISOString(),
485
+ provider_account_id: accountId ?? null,
486
+ });
487
+ if (!sent.ok) {
488
+ return fail(
489
+ `the Crysk platform did not take the renewed login (${describe(sent.status)}); the stored login was spent, so connect the subscription again from the Crysk dashboard.`,
490
+ );
491
+ }
492
+ deps.stdout(
493
+ `::notice title=crysk::${escapeCommandData(`Renewed the ${providerId} subscription login; it expires at ${new Date(expires).toISOString()}.`)}\n`,
494
+ );
495
+ return 0;
496
+ }
497
+
498
+ // Like the trigger and setup steps: the input arrives on stdin, never in the
499
+ // environment of a process bun starts.
500
+ const CRYSK_SECRETS_ENV = "CRYSK_SECRETS_INPUT";
501
+ const CRYSK_SECRETS_STDIN_FLAG = "--crysk-secrets-stdin";
502
+
503
+ if (import.meta.main) {
504
+ if ((process.env[CRYSK_SECRETS_ENV] ?? "") !== "") {
505
+ process.stderr.write(
506
+ `crysk: the crysk-secrets input reached credential-refresh.ts through its environment; pipe it on stdin with ${CRYSK_SECRETS_STDIN_FLAG} and run bun with ${CRYSK_SECRETS_ENV} empty.\n`,
507
+ );
508
+ process.exit(1);
509
+ }
510
+ const cryskSecrets = process.argv.includes(CRYSK_SECRETS_STDIN_FLAG)
511
+ ? await Bun.stdin.text()
512
+ : "";
513
+ process.exit(
514
+ await runCredentialRefresh({
515
+ fetch,
516
+ env: process.env,
517
+ cryskSecrets,
518
+ baseUrl: PLATFORM_API_URL,
519
+ stdout: (text) => process.stdout.write(text),
520
+ now: () => Date.now(),
521
+ sleep: (ms) => Bun.sleep(ms),
522
+ }),
523
+ );
524
+ }
@@ -93,7 +93,8 @@ const CLAUDE_RESERVED_RE = /^CRYSK_CLAUDE_(?:OAUTH_TOKEN|API_KEY)_[A-Z0-9_]+$/;
93
93
  // <P> is exactly the image of opencodeSecretToken: one or more [A-Z0-9] runs
94
94
  // joined by single underscores. The provider runs up to the fixed suffix, so a
95
95
  // provider whose own name ends in `_API` still parses (FOO_API + _API_KEY).
96
- const OPENCODE_RE =
96
+ // Exported for outcome.ts's copy (knownFailureCredential), which a test pins to it.
97
+ export const OPENCODE_SECRET_NAME_RE =
97
98
  /^CRYSK_OPENCODE_([A-Z0-9]+(?:_[A-Z0-9]+)*)_(API_KEY|OAUTH)$/;
98
99
  // A line is NAME=value when it starts with an identifier and an `=`; the value
99
100
  // runs from the FIRST `=`, so base64 padding survives.
@@ -157,6 +158,20 @@ export function opencodeSecretToken(providerId: string): string | undefined {
157
158
  return providerId.toUpperCase().replace(/[.-]/g, "_");
158
159
  }
159
160
 
161
+ // The name of an OpenCode provider's secret of one kind, or undefined when no secret
162
+ // name can carry the provider id. The one builder: chooseOpenCodeSecret and the
163
+ // transport factory (a failed attempt's failureCredential, S7) both use it.
164
+ export function opencodeSecretName(
165
+ providerId: string,
166
+ kind: "api_key" | "oauth",
167
+ ): string | undefined {
168
+ const token = opencodeSecretToken(providerId);
169
+ if (token === undefined) return undefined;
170
+ return kind === "api_key"
171
+ ? `CRYSK_OPENCODE_${token}_API_KEY`
172
+ : `CRYSK_OPENCODE_${token}_OAUTH`;
173
+ }
174
+
160
175
  export function opencodeSecretsFor(
161
176
  secrets: CryskSecrets,
162
177
  providerId: string,
@@ -195,10 +210,9 @@ export function chooseOpenCodeSecret(
195
210
  providerId: string,
196
211
  names: readonly string[],
197
212
  ): OpenCodeSecretChoice | undefined {
198
- const token = opencodeSecretToken(providerId);
199
- if (token === undefined) return undefined;
200
- const apiKey = `CRYSK_OPENCODE_${token}_API_KEY`;
201
- const oauth = `CRYSK_OPENCODE_${token}_OAUTH`;
213
+ const apiKey = opencodeSecretName(providerId, "api_key");
214
+ const oauth = opencodeSecretName(providerId, "oauth");
215
+ if (apiKey === undefined || oauth === undefined) return undefined;
202
216
  const hasApiKey = names.includes(apiKey);
203
217
  if (names.includes(oauth)) {
204
218
  if (providerId !== OPENCODE_OAUTH_SECRET_PROVIDER) {
@@ -364,7 +378,7 @@ export function parseCryskSecrets(raw: string): CryskSecretsParse {
364
378
  }
365
379
 
366
380
  const claudeKind = CLAUDE_NAMES[name];
367
- const opencodeMatch = OPENCODE_RE.exec(name);
381
+ const opencodeMatch = OPENCODE_SECRET_NAME_RE.exec(name);
368
382
  if (claudeKind === undefined && opencodeMatch === null) {
369
383
  notices.push(`${name} is not a Crysk credential name; it is ignored.`);
370
384
  continue;
package/src/ci/gates.ts CHANGED
@@ -8,10 +8,8 @@
8
8
  // comment + marker + step-summary markdown + $GITHUB_OUTPUT, all from the
9
9
  // same numbers, so the shell has no decision left to make beyond "post it /
10
10
  // write it". `budgetDisabledWarningMessage` covers spec 3.1's disabled-
11
- // ceiling `::warning::` requirement. `ciExitCode` pins the assistant-posture
12
- // exit-code contract (spec 2.1): findings, even blocking ones, never fail
13
- // the job — only a fatal session failure or a genuine posting drop (design
14
- // D6) does.
11
+ // ceiling `::warning::` requirement. The exit-code contract (spec 2.1) lives
12
+ // in src/review/exit-code.ts, shared by every mode.
15
13
  //
16
14
  // This module does NOT reimplement the size gate — that gate (deterministic
17
15
  // line/file counting, exclusion globs, the whole cost-predictability
@@ -872,26 +870,6 @@ export function planCiReviewManualRequired(input: {
872
870
  };
873
871
  }
874
872
 
875
- // ---------------------------------------------------------------------------
876
- // Assistant posture — spec 2.1: "The CLI MUST NOT exit with a non-zero code
877
- // merely because findings (even `blocking` ones) were discovered ... exit
878
- // non-zero ONLY on fatal execution failures." `blockingCount` is accepted
879
- // and deliberately NEVER read: its only job is to let a test construct a
880
- // high-blocking-count input and assert the result is still 0, so a future
881
- // change that wires it into this function's logic (the exact regression
882
- // this rule guards against) fails that test rather than shipping silently.
883
- // ---------------------------------------------------------------------------
884
-
885
- export function ciExitCode(input: {
886
- sessionFailed: boolean;
887
- droppedFindingIds: number;
888
- blockingCount: number;
889
- }): 0 | 1 {
890
- if (input.sessionFailed) return 1;
891
- if (input.droppedFindingIds > 0) return 1;
892
- return 0;
893
- }
894
-
895
873
  // ---------------------------------------------------------------------------
896
874
  // CI headless shell's "reviewed" (non-skip) outcome (ROADMAP Pillar 3,
897
875
  // GitHub Actions) — the summary + outputs, and the pure "should I write"