2 Commits

Author SHA1 Message Date
Danny Kim 6c4e4bf67d Move the phase entry points into aliased module folders
Check / check (pull_request) Successful in 46s
2026-10-18 23:58:13 +09:00
Danny Kim 0a9f86a102 Group the sources into aliased modules and lint with the published plugins
Agents / agent (pull_request) Has been skipped
Check / check (pull_request) Successful in 38s
2026-10-18 23:50:27 +09:00
42 changed files with 986 additions and 2398 deletions
@@ -0,0 +1,21 @@
---
description: bot-agents lint has prefer-readonly-parameter-types and the size/complexity rules off (Deno had no limits) and no overrides; nothing else
---
The repo follows [[lint-config-shape]] with one recorded exception, present
when the migration PR was approved:
- `typescript/prefer-readonly-parameter-types` is `"off"` in
`scripts/project-lint.ts`, as in the explicit-types template, because
Node/web types (`Response`, `Stats`, `RequestInit`) can never satisfy it.
- `vite.config.ts` has no `overrides`. The `scripts/**` override for
`typescript/no-unsafe-enum-comparison` was removed (2026-10-16):
`scripts/project-lint.ts` compares node types with `AST_NODE_TYPES` members
from `@typescript-eslint/types` instead of string literals
([[lint-overrides-policy]]).
Size and complexity limits match Deno, which had none here, so every Oxlint
limit rule is `"off"` ([[lint-config-shape]]). `src/run/index.ts` and `src/post/index.ts` keep
main's single-file layout (2026-10-17 revert of the size splits). Sequential
awaits in loops became recursion or a `reduce` chain (`no-await-in-loop`) to
stay sequential. Add no other opt-out without the user.
@@ -21,11 +21,13 @@ Node + Vite+ migration (PR #20, `node-migration`, 2026-10-15/16):
- **Published lint plugins** (2026-10-18, after they reached npm): - **Published lint plugins** (2026-10-18, after they reached npm):
`eslint-plugin-import-structure` (`modules` config) and `eslint-plugin-import-structure` (`modules` config) and
`eslint-plugin-explicit-types` (`concrete` and `absence` configs) are `eslint-plugin-explicit-types` (`concrete` and `absence` configs) are
devDependencies, enabled in `vite.config.ts` through their `all` configs. devDependencies, enabled in `vite.config.ts`. explicit-types' `naming`
`upper-snake-string-unions` was off while the user decided; since config is left off: its `upper-snake-string-unions` and
2026-10-19 it is on and profile types, failure reasons, and anchor sides `no-upper-snake-object-keys` rules fire on wire tokens this repo does not
are `UPPER_SNAKE` ([[enum-values-upper-snake]]). `eslint-plugin-lit-robust` name (profile types such as `"claude"`, failure reasons posted to Gitea,
does not apply (no Lit). environment variable names), which cannot change without changing
behavior. Open question for the user. `eslint-plugin-lit-robust` does not apply
(no Lit).
- **Stricter input checks were accepted** in the migration: Gitea `/user` and - **Stricter input checks were accepted** in the migration: Gitea `/user` and
comment responses, the runtime manifest, and the outcome's profile type are comment responses, the runtime manifest, and the outcome's profile type are
validated; some type errors became `TypeError` with the same messages. validated; some type errors became `TypeError` with the same messages.
-48
View File
@@ -1,48 +0,0 @@
---
description: Enum-like string values are UPPER_SNAKE everywhere this repo owns the format, JSON included; external standards are converted at the boundary with explicit switch functions
---
Decided 2026-10-19 (all repos). An enum-like string value, a member of a
string-literal union, is `UPPER_SNAKE` wherever this repo owns the format:
TypeScript unions, `profiles.json`, the runtime outcome file, and the
`anchors.json` the agent writes per `prompt.md`. explicit-types
`upper-snake-string-unions` enforces it and stays on.
A value an outside party defines (a CLI flag, an environment variable name,
an HTTP API field, a human-readable message) is converted at the boundary by
an explicit `switch` function, never by renaming our own values to match it:
```ts
export interface ProfileIdentity {
type: "CLAUDE" | "CODEX" | "OPENCODE";
model: string;
}
// The agent name the skills installer knows each profile type by.
function skillsAgent(type: RuntimeProfile["type"]): string {
switch (type) {
case "CLAUDE":
return "claude-code";
case "CODEX":
return "codex";
case "OPENCODE":
return "opencode";
}
}
```
In this repo:
- Profile `type`: `CLAUDE`, `CODEX`, `OPENCODE` (also in `profiles.json`).
`skillsAgent()` (run phase) and `tokenVariable()` (profiles) map them to the
installer's agent name and the credential environment variable;
`defaultModel()` (credentials) picks a model.
- `FailureReason`: `SIGN_IN_FAILED`, `USAGE_EXHAUSTED`, `FAILED`; `toMessage()`
gives the words that logs and posted comments show.
- Anchor `side`: `NEW` or `OLD` (`prompt.md` tells the agent so); the Gitea
review call turns it into `new_position` / `old_position`.
A lookup object keyed by enum values would need `UPPER_SNAKE` keys, which
explicit-types `no-upper-snake-object-keys` bans, so use a `switch`. TypeScript
checks such a switch for exhaustiveness through the declared return type; no
`default:` branch ([[lint-config]]).
+1 -1
View File
@@ -72,7 +72,7 @@ import { x } from "../x.ts"; // no: no ../ anywhere
- An area used from outside exposes its API through its alias target, and - An area used from outside exposes its API through its alias target, and
callers import the alias (`#ui`), not files inside it. callers import the alias (`#ui`), not files inside it.
- Barrels are also the standard fix for `import/max-dependencies`: one barrel - Barrels are also the standard fix for `import/max-dependencies`: one barrel
import replaces many direct ones ([[lint-config]]). import replaces many direct ones ([[lint-overrides-policy]]).
- `import/no-cycle` is on; a barrel must not create a cycle. - `import/no-cycle` is on; a barrel must not create a cycle.
Relative imports are written with the `.ts` extension. Relative imports are written with the `.ts` extension.
+48
View File
@@ -0,0 +1,48 @@
---
description: vite.config.ts lint uses Oxlint categories at error with Deno size limits, names no rule itself, and spreads configs from the plugins and scripts/project-lint.ts
---
The lint config is short and category-driven (user decisions 2026-10-14/15):
turn on whole categories, then list only what parity or a real need adds.
```ts
lint: {
plugins: ["typescript", "unicorn", "oxc", "import"],
jsPlugins: ["eslint-plugin-explicit-types", "./scripts/project-lint.ts"],
categories: { correctness: "error", suspicious: "error", pedantic: "error", perf: "error" },
rules: { ...explicitTypes.configs.concrete.rules, ...projectLint.configs.project.rules },
ignorePatterns: ["src/generated/**"], // generated files only, see below
options: { typeAware: true, typeCheck: true, maxWarnings: 0, reportUnusedDisableDirectives: "error" },
},
```
- **Categories:** `correctness`, `suspicious`, `pedantic`, `perf` at `error`.
`style` and `restriction` are never turned on wholesale; pick single rules
from them in `configs.project`. Extra rules that categories bring are fine.
- **Size limits match Deno** (2026-10-17, replaces the 2026-10-16 "default
limits stay"): repos behave as they did on Deno. bot-agents ran `deno lint`
with no config, so it had no size or complexity limit, and every Oxlint
limit rule (`complexity`, `max-lines`, `max-params`, `id-length`,
`no-nested-ternary`, `max-lines-per-function`, `max-classes-per-file`,
`max-depth`, `max-nested-callbacks`, `max-statements`,
`import/max-dependencies`, `unicorn/max-nested-calls`) is `"off"` in
`configs.project`. No file is split for size. Do not add new opt-outs
anywhere without asking the user.
- **`vite.config.ts` names no rule.** Every rule id, built-in ones included,
lives in `configs.project` of `scripts/project-lint.ts`
([[project-lint-plugin]]). `vite.config.ts` only spreads configs.
- **Published plugins are consumed through their configs**: ESLint flat config
uses `plugin.configs.<name>`; Oxlint lists the package in `jsPlugins` and
spreads `plugin.configs.<name>.rules`, since Oxlint plugins carry no configs.
Use the configs equivalent to what the repo enabled under Deno.
- **`maxWarnings: 0`** keeps Deno's "every diagnostic fails" behaviour.
- **`ignorePatterns`** is only for generated files (compiled output, codegen).
Hand-written code is never ignored.
- **No lint disable comments**: [[lint-no-disable-comments]].
- **Parity:** [[lint-parity-never-shrinks]]. **Naming:** [[naming-id-match]].
- Don't add a second import sorter; the import-structure plugin's
`enforce-import-order` is the only one, and Oxfmt's `sortImports` stays off.
`perf` came last: in the template it flagged nine `.includes` on constant
arrays, fixed as `ReadonlySet` + `.has()` rather than by turning a rule off.
That is the expected response to any new rule: change the code.
-102
View File
@@ -1,102 +0,0 @@
---
description: Lint config shape: every non-nursery Oxlint category on, plugins via `all`, a blacklist of offs in configs.project, per-file exceptions only in projectOverrides, ignorePatterns only for generated output
---
Policy (2026-10-19): a blacklist, not a whitelist. Replaces the older
category-subset and "no overrides" notes.
- **Categories:** `correctness`, `suspicious`, `pedantic`, `perf`, `style`,
`restriction` at `error`. `nursery` stays off (no line for it).
- **Plugins** are enabled whole through their `all` config
(`explicitTypes.configs.all.rules`, `importStructure.configs.all.rules`).
- **Blacklist:** repo-wide offs and option tweaks live in
`projectLint.configs.project.rules` in `scripts/project-lint.ts`, spread
last in `rules`, each with a one-line reason. Never re-list a rule a
category already turns on. bot-agents runs on Node everywhere, so
`import/no-nodejs-modules`, `unicorn/no-process-exit`, and `no-console` are
off repo-wide.
- **Per-file exceptions** only via `projectOverrides`, the whole `overrides`
array exported from `scripts/project-lint.ts`: the Node code entry
(`vite.config.ts`, `scripts/**`, `nodeRules`) first, then one entry per
exception with a why-comment. `vite.config.ts` has exactly
`overrides: projectOverrides`.
- **No `allowFiles`** options in custom rules, and no disable comments
([[lint-no-disable-comments]]).
- **`ignorePatterns`** only for generated or build output, never hand-written
code. A hand-written file is linted, with override entries for only what it
legitimately breaks. bot-agents has no generated code, so none.
- **Precedence:** categories < `rules` (a later spread wins) < `overrides` (a
later entry wins).
- Size and complexity limits (`complexity`, `max-lines`, ...) are set to the
smallest value the current code passes.
```ts
// scripts/project-lint.ts
export const projectOverrides: OxlintOverride[] = [
{ files: ["vite.config.ts", "scripts/**"], rules: nodeRules },
// Why: src/example.ts must ... (a per-file exception, if one is ever needed)
// { files: ["src/example.ts"], rules: { "some-rule": "off" } },
];
// vite.config.ts
rules: {
...explicitTypes.configs.all.rules,
...importStructure.configs.all.rules,
...projectLint.configs.project.rules,
},
overrides: projectOverrides,
```
## Rule decisions (2026-10-19, all repos)
- `typescript/promise-function-async` is on with `require-await` and
`typescript/return-await`. A function that returns a promise is `async`
and awaits it: `async f() { const x = await g(); return x; }`. Test
doubles do the same (`const resolved = await Promise.resolve(v); return
resolved;`), and `expect(promise).rejects` takes the promise itself.
`src/processes/child.ts` is exempt in `projectOverrides`: `exitCode` must
return the very promise it marks handled, or a failed spawn would surface
as an unhandled rejection before callers await it.
- `init-declarations` is on: an uninitialized `let` becomes
`let x: T | null = null;` (`unknown` already includes `null`); a `try` that
assigns and a `catch` that exits still narrow it.
- `no-use-before-define` is on with only `{ functions: false }`.
- `no-await-in-loop` is off (sequential awaits are intentional) and
`unicorn/no-array-reduce` is on: sequential steps are plain `for` loops,
never `reduce` chains or recursion.
- `consistent-return`, `typescript/switch-exhaustiveness-check`, and
`default-case` are off: TypeScript's checks cover them, and no `default:`
branch is added to an exhaustive switch.
- `unknown` is allowed; `any` is banned and the `typescript/no-unsafe-*`
rules are on. Untrusted data is `unknown` plus a type guard.
- `unicorn/no-array-for-each` (use `for...of`),
`unicorn/prefer-structured-clone`, and `typescript/prefer-nullish-coalescing`
(defaults) stay on.
- explicit-types `upper-snake-string-unions` is on
([[enum-values-upper-snake]]); `unicorn/custom-error-definition` is on, so a
custom error has a constructor that sets `this.name`.
- `src/post/` and `src/profiles/` (code and tests) are exempt from
`project/prefer-ascii` in `projectOverrides`: posted Gitea text shows emoji
verdict marks and a middle dot.
## Rule decisions (2026-10-20, all repos)
- `unicorn/number-literal-case` is off: Oxfmt lowercases hex digits back.
- `typescript/consistent-return` is off too: it misfires on complete
switches, like `consistent-return`.
- On with defaults, no offs: `prefer-object-spread`, `unicorn/prefer-spread`,
`unicorn/no-useless-spread`, `typescript/no-misused-spread`, `no-plusplus`
(`x += 1`), `unicorn/no-array-method-this-argument`,
`typescript/method-signature-style` ("property"),
`typescript/unified-signatures`.
- `unicorn/import-style` uses its default: `import nodePath from "node:path"`
and `nodePath.join(...)` (`nodePath`, since `path` is a common variable).
- `no-template-curly-in-string` is on; only `tests/workflow.test.ts`, which
checks literal Gitea `${{ }}` expressions, is exempt in `projectOverrides`.
- Rule defaults are preferred over option tweaks unless a tweak is needed.
- `fmt` matches `deno fmt`: `printWidth: 80`, `quoteProps: "preserve"`,
`embeddedLanguageFormatting: "off"`. `max-lines-per-function` is 124 after
the narrower width.
A new category hit is fixed in the code; an off or exception is added only
for a real collision or churn, with its reason. Rules: [[project-lint-plugin]].
+33
View File
@@ -0,0 +1,33 @@
---
description: No lint overrides for source files; narrow ones only for scripts/**; generated files go in ignorePatterns; size limits match Deno, so nothing is split for size
---
Final policy (2026-10-16). The user considers per-file `overrides` bad
practice.
- **Source files: never.** No `overrides` entry may target `src/**` or any
other hand-written production or test code.
- **The one exception** is in lint-plugin repos: `import/max-dependencies`
off for `src/rules/index.ts`, the rule registry, which must import every
rule. It is not a precedent for apps.
- **`scripts/**`:** a narrow override is allowed when a tooling script truly
needs it, e.g. `no-console` in a CLI script.
- **Generated files:** list them in `ignorePatterns`, never `overrides`.
- **Anything else needs the user's approval first.** When the user is away,
don't add it: refactor, or leave the violation failing and log the question.
## Fix the code instead
Category rule violations are fixed in the code without behavior change,
covered by the tests, inside the same migration PR; e.g. `prefer-set-has`
becomes `const K: ReadonlySet<string> = new Set([...])` with `.has`.
Size and complexity limits are not refactored for: they match what Deno
enforced (2026-10-17, replacing the earlier "refactor to Oxlint's defaults"),
which for bot-agents is none, so those rules are `"off"`
([[lint-config-shape]]).
Alias rule: an alias may point anywhere and owns its target (a folder's
`index.ts` owns the folder and below, any other file owns only itself); no
two aliases may own the same file, and `../` is banned everywhere
([[imports-aliases-barrels]]).
+7 -14
View File
@@ -11,19 +11,12 @@ Oxlint plugin with `meta.name` `"project"`, loaded through `jsPlugins` in
plugin configs: Deno parity rules, extras, per-rule options, and opt-outs, plugin configs: Deno parity rules, extras, per-rule options, and opt-outs,
built-in Oxlint ids included (`curly`, `id-match`, `import/no-cycle`, ...). built-in Oxlint ids included (`curly`, `id-match`, `import/no-cycle`, ...).
- **Custom rules**, enabled as `project/<rule>`. Every repo has - **Custom rules**, enabled as `project/<rule>`. Every repo has
`no-disable-comments` and `no-asset-imports`. Since 2026-10-19 every repo `no-disable-comments` and `no-asset-imports`; bot-agents has no others.
also has `prefer-ascii`, `no-nan` (a "no number" value is `null`, never
`NaN`), and the hugoalh `recommended` ports from
eslint-plugin-import-structure's own lint: `no-duplicate-typeofs`,
`no-empty-yield`, `no-unsafe-number`, `no-useless-continue`,
`no-duplicate-interfaces`, `no-duplicate-types`, `no-useless-type`, and
`no-modifier-private`. `no-duplicate-awaits` and `no-duplicate-voids` are
covered by `unicorn/no-unnecessary-await` and
`typescript/no-meaningless-void-operator`, and `no-enum` by explicit-types.
`scripts/` stays flat; don't add `scripts/rules/`. All rules live in the one `scripts/` stays flat; don't add `scripts/rules/`. If the plugin ever needs
`scripts/project-lint.ts` (no file splitting), next to the plugin object and more files, they sit flat beside it and share the prefix
the rule list. (`project-lint-modules.ts`, ...); `scripts/project-lint.ts` keeps the plugin
object and the rule list.
```ts ```ts
import type { DummyRuleMap } from "vite-plus/lint"; import type { DummyRuleMap } from "vite-plus/lint";
@@ -59,5 +52,5 @@ export default plugin;
and every repo should look the same. and every repo should look the same.
`scripts/` is tooling, not production code: never packed or published, and `scripts/` is tooling, not production code: never packed or published, and
no tests. Its offs sit in the Node code entry of `projectOverrides`; see no tests. Narrow `overrides` for `scripts/**` are allowed when a script truly
[[lint-config]]. needs one (e.g. `no-console`); see [[lint-overrides-policy]].
+3 -5
View File
@@ -50,11 +50,9 @@ relative imports. `scripts/` is flat: one file per tool, no subfolders and no `i
([.agents/memory/imports-aliases-barrels.md](.agents/memory/imports-aliases-barrels.md)). ([.agents/memory/imports-aliases-barrels.md](.agents/memory/imports-aliases-barrels.md)).
The only config files are `package.json`, `tsconfig.json`, and The only config files are `package.json`, `tsconfig.json`, and
`vite.config.ts`, plus `package-lock.json`. Repo-local lint rules, the rule `vite.config.ts`, plus `package-lock.json`. Repo-local lint rules and the rule
list, and the `overrides` array (`projectOverrides`) live in list live in `scripts/project-lint.ts`. Lint disable comments are not allowed;
`scripts/project-lint.ts` fix the source instead.
([.agents/memory/lint-config.md](.agents/memory/lint-config.md)). Lint disable
comments are not allowed; fix the source instead.
The composite action uses npm only to install the externally distributed The composite action uses npm only to install the externally distributed
Claude Code, Codex, and OpenCode command-line tools; do not treat those Claude Code, Codex, and OpenCode command-line tools; do not treat those
+8 -16
View File
@@ -9,8 +9,8 @@
"@eslint/core": "^0.17.0", "@eslint/core": "^0.17.0",
"@types/node": "^24.19.2", "@types/node": "^24.19.2",
"@typescript-eslint/types": "^8.71.2", "@typescript-eslint/types": "^8.71.2",
"eslint-plugin-explicit-types": "^0.7.2", "eslint-plugin-explicit-types": "^0.6.1",
"eslint-plugin-import-structure": "^0.12.0", "eslint-plugin-import-structure": "^0.10.2",
"vite-plus": "^1.2.0", "vite-plus": "^1.2.0",
"yaml": "^2.9.1" "yaml": "^2.9.1"
} }
@@ -1890,9 +1890,9 @@
"license": "MIT" "license": "MIT"
}, },
"node_modules/eslint-plugin-explicit-types": { "node_modules/eslint-plugin-explicit-types": {
"version": "0.7.2", "version": "0.6.1",
"resolved": "https://registry.npmjs.org/eslint-plugin-explicit-types/-/eslint-plugin-explicit-types-0.7.2.tgz", "resolved": "https://registry.npmjs.org/eslint-plugin-explicit-types/-/eslint-plugin-explicit-types-0.6.1.tgz",
"integrity": "sha512-ffHVVuyBH2esZwwRItcz2sDnL5xvSRDAoLjSqmQbevT6ETcjtfThtLoWoc+cv5pvtxa6YiXEK1P2D+x/yUBc1g==", "integrity": "sha512-8JU2Ceoi1aLbhYo4LHwb9Eone/pJuMnzVP1ZlGJn/ETxVzJQFziRnJwOF2dRmInn9dGqvwq05dc3o5tVyTGP2Q==",
"dev": true, "dev": true,
"license": "MIT", "license": "MIT",
"dependencies": { "dependencies": {
@@ -1903,9 +1903,9 @@
} }
}, },
"node_modules/eslint-plugin-import-structure": { "node_modules/eslint-plugin-import-structure": {
"version": "0.12.0", "version": "0.10.2",
"resolved": "https://registry.npmjs.org/eslint-plugin-import-structure/-/eslint-plugin-import-structure-0.12.0.tgz", "resolved": "https://registry.npmjs.org/eslint-plugin-import-structure/-/eslint-plugin-import-structure-0.10.2.tgz",
"integrity": "sha512-axo8TH0mik9NmsnW+J5rNwNXlOxxqOhULwN7zE4EJaNRdk/Ci/aRac3BAeeIi/SDUyPgN6Ig34l+mFlLQYWkfw==", "integrity": "sha512-jvx4sccxEdURGXrDtBJZtCHiKqELkHRVlLrMU5bVZIjglN0U464Joopcfn6JvmNB2zyIh2FkolaJQJaKkvy6Xw==",
"dev": true, "dev": true,
"license": "MIT", "license": "MIT",
"dependencies": { "dependencies": {
@@ -1913,14 +1913,6 @@
}, },
"engines": { "engines": {
"node": ">=22.18" "node": ">=22.18"
},
"peerDependencies": {
"eslint": ">=9"
},
"peerDependenciesMeta": {
"eslint": {
"optional": true
}
} }
}, },
"node_modules/estree-walker": { "node_modules/estree-walker": {
+2 -2
View File
@@ -18,8 +18,8 @@
"@eslint/core": "^0.17.0", "@eslint/core": "^0.17.0",
"@types/node": "^24.19.2", "@types/node": "^24.19.2",
"@typescript-eslint/types": "^8.71.2", "@typescript-eslint/types": "^8.71.2",
"eslint-plugin-explicit-types": "^0.7.2", "eslint-plugin-explicit-types": "^0.6.1",
"eslint-plugin-import-structure": "^0.12.0", "eslint-plugin-import-structure": "^0.10.2",
"vite-plus": "^1.2.0", "vite-plus": "^1.2.0",
"yaml": "^2.9.1" "yaml": "^2.9.1"
} }
+6 -6
View File
@@ -2,16 +2,16 @@
"reviewer-token": "v1:XFUvCI9PnXVaW-ig:_3S9BvXywUp29cVYGA_EzFScKwC5oHkV9x2Ld8k-V_uiG7iA8n3fmjXCArzh2Lz-JDgy3IMTHoY", "reviewer-token": "v1:XFUvCI9PnXVaW-ig:_3S9BvXywUp29cVYGA_EzFScKwC5oHkV9x2Ld8k-V_uiG7iA8n3fmjXCArzh2Lz-JDgy3IMTHoY",
"profiles": [ "profiles": [
{ {
"type": "CLAUDE", "type": "codex",
"model": "gpt-5.6-terra"
},
{
"type": "claude",
"model": "claude-sonnet-5", "model": "claude-sonnet-5",
"token": "v1:-dyfF6ZicEhjPk4C:WCuMaGd09tYjtzUCl7abloRzPITvP5C35WpR372w3O_tcaD-ls-yV5sJBdU8iIVApZVCC98sY2gOyM3o9RMa8ciJq8Fuys7KxlYOp8QiluL9AYMSQi6rEsSH71EPWnxSACgo3uDQY8bWQpUlEZvXH9O-ZN9A58dh6b3vRg" "token": "v1:-dyfF6ZicEhjPk4C:WCuMaGd09tYjtzUCl7abloRzPITvP5C35WpR372w3O_tcaD-ls-yV5sJBdU8iIVApZVCC98sY2gOyM3o9RMa8ciJq8Fuys7KxlYOp8QiluL9AYMSQi6rEsSH71EPWnxSACgo3uDQY8bWQpUlEZvXH9O-ZN9A58dh6b3vRg"
}, },
{ {
"type": "CODEX", "type": "opencode",
"model": "gpt-5.6-terra"
},
{
"type": "OPENCODE",
"model": "openrouter/qwen/qwen3.8-27b", "model": "openrouter/qwen/qwen3.8-27b",
"token": "v1:4qdfJCdUx9jfiabC:8X0ic_J82lPlq_R3uTLaEbQy7UmEh7BgtG0bDKAcc8FeJ0xvEwkGCKaDoLmT5nta03hgjGdcWKjDdOSMi1kSDfp8J7tRTLtMRzDT8GX8OU_PVDPVahQIAU0" "token": "v1:4qdfJCdUx9jfiabC:8X0ic_J82lPlq_R3uTLaEbQy7UmEh7BgtG0bDKAcc8FeJ0xvEwkGCKaDoLmT5nta03hgjGdcWKjDdOSMi1kSDfp8J7tRTLtMRzDT8GX8OU_PVDPVahQIAU0"
} }
+3 -3
View File
@@ -47,9 +47,9 @@ achieved.
Every finding that belongs to one line of the diff goes on that line instead of Every finding that belongs to one line of the diff goes on that line instead of
into the body. Write those to `${ANCHORS_PATH}` as a JSON array, each entry into the body. Write those to `${ANCHORS_PATH}` as a JSON array, each entry
`{"path": "<path from the repository root>", "line": <number>, "side": "NEW" | `{"path": "<path from the repository root>", "line": <number>, "side": "new" |
"OLD", "body": "<the finding>"}`. "old", "body": "<the finding>"}`.
`side` is `NEW` for a line in the head file and `OLD` for one only in the base `side` is `new` for a line in the head file and `old` for one only in the base
file; `line` is that file's own line number, and it must be a line the diff file; `line` is that file's own line number, and it must be a line the diff
touches, or Gitea refuses the anchor. Write the file only when there is touches, or Gitea refuses the anchor. Write the file only when there is
something to anchor, and keep each body to the what, the why, and the how, with something to anchor, and keep each body to the what, the why, and the how, with
+80 -773
View File
@@ -1,29 +1,20 @@
/** /**
* `project` - this repository's changes to the Oxlint categories in * `project` — lint rules this repository holds its own source to, on top of
* `vite.config.ts`. Its rules of its own are `no-disable-comments`, * the Oxlint categories in `vite.config.ts`. Its rules of its own are
* `no-asset-imports`, `prefer-ascii`, and ports of the hugoalh `recommended` * `no-disable-comments` and `no-asset-imports`.
* rules Oxlint lacks, as in eslint-plugin-import-structure's own lint.
* *
* Loaded by `vite.config.ts` as an Oxlint `jsPlugins` entry. * Loaded by `vite.config.ts` as an Oxlint `jsPlugins` entry.
* *
* @module * @module
*/ */
import type { import type { LanguageOptions, RuleDefinition, RuleVisitor, TextSourceCode } from "@eslint/core";
LanguageOptions,
Position,
RuleDefinition,
RuleTextEdit,
RuleVisitor,
TextSourceCode,
} from "@eslint/core";
import { AST_NODE_TYPES, type TSESTree } from "@typescript-eslint/types"; import { AST_NODE_TYPES, type TSESTree } from "@typescript-eslint/types";
import type { DummyRuleMap, OxlintOverride } from "vite-plus/lint"; import type { DummyRuleMap } from "vite-plus/lint";
/** The source code both hosts hand a rule, with the comment list and index lookup. */ /** The source code both hosts hand a rule, with the comment list. */
interface ProjectSourceCode extends TextSourceCode { interface ProjectSourceCode extends TextSourceCode {
getAllComments: () => TSESTree.Comment[]; getAllComments(): TSESTree.Comment[];
getLocFromIndex: (index: number) => Position;
} }
/** ESLint's default rule types, reporting TypeScript-ESTree nodes. */ /** ESLint's default rule types, reporting TypeScript-ESTree nodes. */
@@ -47,7 +38,7 @@ const DIRECTIVE_PATTERN: RegExp = /^\s*(?:eslint|oxlint)-(?:disable|enable)/u;
const RULE_NAME: string = "no-disable-comments"; const RULE_NAME: string = "no-disable-comments";
/** /**
* `no-disable-comments` - rejects every `eslint-disable*`, `eslint-enable*`, * `no-disable-comments` — rejects every `eslint-disable*`, `eslint-enable*`,
* `oxlint-disable*`, and `oxlint-enable*` comment, line or block. Oxlint has * `oxlint-disable*`, and `oxlint-enable*` comment, line or block. Oxlint has
* no `noInlineConfig` and no `eslint-comments` rules, so this repo bans them * no `noInlineConfig` and no `eslint-comments` rules, so this repo bans them
* itself: when a rule fires, fix the source. * itself: when a rule fires, fix the source.
@@ -62,18 +53,13 @@ const noDisableCommentsRule: ProjectRule = {
type: "problem", type: "problem",
docs: { description: "Disallow lint disable and enable comments" }, docs: { description: "Disallow lint disable and enable comments" },
schema: [], schema: [],
messages: { messages: { directive: "Lint disable comments are not allowed; fix the source." },
directive: "Lint disable comments are not allowed; fix the source.",
},
}, },
create(context) { create(context) {
return { return {
Program(_node: TSESTree.Program): void { Program(_node: TSESTree.Program): void {
for (const comment of context.sourceCode.getAllComments()) { for (const comment of context.sourceCode.getAllComments()) {
if ( if (DIRECTIVE_PATTERN.test(comment.value) && !comment.value.includes(RULE_NAME)) {
DIRECTIVE_PATTERN.test(comment.value) &&
!comment.value.includes(RULE_NAME)
) {
context.report({ loc: comment.loc, messageId: "directive" }); context.report({ loc: comment.loc, messageId: "directive" });
} }
} }
@@ -82,565 +68,6 @@ const noDisableCommentsRule: ProjectRule = {
}, },
}; };
/** The highest code point `prefer-ascii` lets through. */
const MAX_ASCII_CODE_POINT: number = 127;
/**
* `prefer-ascii` - every character of the source is ASCII. A file is exempted
* only through an entry in `projectOverrides`.
*/
const preferAsciiRule: ProjectRule = {
meta: {
type: "suggestion",
docs: { description: "Require the source to be ASCII" },
schema: [],
messages: {
nonAscii:
"Non-ASCII character '{{character}}' (U+{{codePoint}}) is not allowed.",
},
},
create(context) {
return {
Program(_node: TSESTree.Program): void {
const { sourceCode } = context;
let index: number = 0;
for (const character of sourceCode.text) {
const codePoint: number = character.codePointAt(0) ?? 0;
if (codePoint > MAX_ASCII_CODE_POINT) {
context.report({
loc: {
start: sourceCode.getLocFromIndex(index),
end: sourceCode.getLocFromIndex(index + character.length),
},
messageId: "nonAscii",
data: {
character,
codePoint: codePoint
.toString(16)
.toUpperCase()
.padStart(4, "0"),
},
});
}
index += character.length;
}
},
};
},
};
/** `no-duplicate-typeofs` - `typeof typeof x` is always `"string"`. */
const noDuplicateTypeofsRule: ProjectRule = {
meta: {
type: "problem",
docs: { description: "Disallow `typeof` applied twice in a row" },
schema: [],
messages: {
doubled:
'Multiple `typeof`s always return `"string"`, possibly not intended.',
},
},
create(context) {
return {
UnaryExpression(node: TSESTree.UnaryExpression): void {
if (
node.operator === "typeof" &&
node.argument.type === AST_NODE_TYPES.UnaryExpression &&
node.argument.operator === "typeof"
) {
context.report({ node, messageId: "doubled" });
}
},
};
},
};
/** `no-empty-yield` - a `yield` with no expression, likely missing one. */
const noEmptyYieldRule: ProjectRule = {
meta: {
type: "problem",
docs: { description: "Disallow `yield` without an expression" },
schema: [],
messages: {
empty: "Empty `yield` is not allowed, possibly missing the expression.",
},
},
create(context) {
return {
YieldExpression(node: TSESTree.YieldExpression): void {
if (node.argument === null) {
context.report({ node, messageId: "empty" });
}
},
};
},
};
/** The globals `no-nan` sees through, as in `globalThis.Number.NaN`. */
const GLOBAL_NAMES: ReadonlySet<string> = new Set<string>([
"globalThis",
"self",
"window",
]);
/** The name a member expression's property spells, computed or not. */
function propertyName(node: TSESTree.MemberExpression): string | null {
if (node.property.type === AST_NODE_TYPES.Identifier && !node.computed) {
return node.property.name;
}
if (
node.property.type === AST_NODE_TYPES.Literal &&
typeof node.property.value === "string"
) {
return node.property.value;
}
return null;
}
/** Whether `node` is a global object, such as `globalThis` or `globalThis.self`. */
function isGlobalChain(node: TSESTree.Expression): boolean {
if (node.type === AST_NODE_TYPES.Identifier) {
return GLOBAL_NAMES.has(node.name);
}
return (
node.type === AST_NODE_TYPES.MemberExpression &&
GLOBAL_NAMES.has(propertyName(node) ?? "") &&
isGlobalChain(node.object)
);
}
/**
* Whether a member expression reads the global `NaN`: `Number.NaN`,
* `globalThis.NaN`, or `globalThis.Number.NaN`.
*/
function isNanMember(node: TSESTree.MemberExpression): boolean {
if (propertyName(node) !== "NaN") {
return false;
}
const { object } = node;
if (object.type === AST_NODE_TYPES.Identifier && object.name === "Number") {
return true;
}
return (
isGlobalChain(object) ||
(object.type === AST_NODE_TYPES.MemberExpression &&
propertyName(object) === "Number" &&
isGlobalChain(object.object))
);
}
/** `no-nan` - a `NaN` value is usually an error; use `null` for "no number". */
const noNanRule: ProjectRule = {
meta: {
type: "problem",
docs: { description: "Disallow `NaN` as a value" },
schema: [],
messages: {
nan: "Using `NaN` as a value is usually an error and not intended.",
},
},
create(context) {
return {
Identifier(node: TSESTree.Identifier): void {
if (
node.name === "NaN" &&
node.parent.type !== AST_NODE_TYPES.MemberExpression
) {
context.report({ node, messageId: "nan" });
}
},
MemberExpression(node: TSESTree.MemberExpression): void {
if (isNanMember(node)) {
context.report({ node, messageId: "nan" });
}
},
};
},
};
/** `no-unsafe-number` - a number literal outside the safe integer range. */
const noUnsafeNumberRule: ProjectRule = {
meta: {
type: "problem",
docs: {
description: "Disallow number literals outside the safe integer range",
},
schema: [],
messages: {
unsafe:
"Number literals with values equal to 2^53 or greater are too large to be represented accurately.",
},
},
create(context) {
return {
Literal(node: TSESTree.Literal): void {
if (
typeof node.value === "number" &&
(node.value < Number.MIN_SAFE_INTEGER ||
node.value > Number.MAX_SAFE_INTEGER)
) {
context.report({ node, messageId: "unsafe" });
}
},
};
},
};
/** A loop statement, whose last `continue` `no-useless-continue` checks. */
type LoopStatement =
| TSESTree.DoWhileStatement
| TSESTree.ForInStatement
| TSESTree.ForOfStatement
| TSESTree.ForStatement
| TSESTree.WhileStatement;
/** A loop's trailing unlabeled `continue`, and whether removing it is a safe fix. */
interface TrailingContinue {
statement: TSESTree.ContinueStatement;
removable: boolean;
}
/**
* The unlabeled `continue` a loop ends with, and whether removing it is a
* safe fix: it is in a block, rather than the loop's whole body.
*/
function trailingContinue(node: LoopStatement): TrailingContinue | null {
if (node.body.type === AST_NODE_TYPES.BlockStatement) {
const last = node.body.body.at(-1);
return last?.type === AST_NODE_TYPES.ContinueStatement &&
last.label === null
? { statement: last, removable: true }
: null;
}
if (
node.body.type === AST_NODE_TYPES.ContinueStatement &&
node.body.label === null
) {
return { statement: node.body, removable: false };
}
return null;
}
/**
* `no-useless-continue` - an unlabeled `continue` that ends a loop body. A
* trailing `continue;` in a block is removed by the fix; a loop whose whole
* body is `continue;` is only reported.
*/
const noUselessContinueRule: ProjectRule = {
meta: {
type: "suggestion",
docs: {
description: "Disallow an unlabeled `continue` at the end of a loop",
},
fixable: "code",
schema: [],
messages: {
useless:
"The statement `continue` at the end of the loop and without a label is useless.",
},
},
create(context) {
function check(node: LoopStatement): void {
const found: TrailingContinue | null = trailingContinue(node);
if (found === null) {
return;
}
if (found.removable) {
context.report({
node: found.statement,
messageId: "useless",
fix: (fixer): RuleTextEdit => fixer.remove(found.statement),
});
} else {
context.report({ node: found.statement, messageId: "useless" });
}
}
return {
DoWhileStatement: check,
ForInStatement: check,
ForOfStatement: check,
ForStatement: check,
WhileStatement: check,
};
},
};
/** Node keys that say where a node is, not what it is, in ESLint and Oxlint. */
const POSITION_KEYS: ReadonlySet<string> = new Set<string>([
"parent",
"range",
"loc",
"start",
"end",
]);
/** Node types whose member lists mean the same in any order. */
const UNORDERED_TYPES: ReadonlySet<string> = new Set<string>([
"TSInterfaceBody",
"TSTypeLiteral",
"TSUnionType",
"TSIntersectionType",
]);
/** Type annotations too simple for an alias of their own (`no-useless-type`). */
const SIMPLE_TYPES: ReadonlySet<string> = new Set<string>([
"TSAnyKeyword",
"TSBigIntKeyword",
"TSBooleanKeyword",
"TSIntrinsicKeyword",
"TSNeverKeyword",
"TSNullKeyword",
"TSNumberKeyword",
"TSObjectKeyword",
"TSStringKeyword",
"TSSymbolKeyword",
"TSUndefinedKeyword",
"TSUnknownKeyword",
"TSVoidKeyword",
]);
/**
* A node's shape as text, without positions, so two declarations compare
* alike wherever they sit. Members of a type literal, interface body,
* union, or intersection are sorted, since their order means nothing.
*/
function serialize(value: unknown): string {
if (Array.isArray(value)) {
return `[${value.map((item: unknown) => serialize(item)).join(",")}]`;
}
if (typeof value !== "object" || value === null) {
return JSON.stringify(value) ?? "undefined";
}
const unordered: boolean =
"type" in value && UNORDERED_TYPES.has(String(value.type));
const parts: string[] = Object.entries(value)
.filter(([key]: [string, unknown]) => !POSITION_KEYS.has(key))
.map(([key, child]: [string, unknown]) => {
const text: string =
unordered && Array.isArray(child)
? `[${child
.map((item: unknown) => serialize(item))
.toSorted()
.join(",")}]`
: serialize(child);
return `${key}:${text}`;
});
return `{${parts.join(",")}}`;
}
/** The top-level declarations in a block, exported or not, that `matches`. */
function declarationsOf<T extends TSESTree.Node>(
statements: TSESTree.Node[],
matches: (node: TSESTree.Node) => node is T,
): T[] {
const found: T[] = [];
for (const statement of statements) {
const declaration: TSESTree.Node | null =
statement.type === AST_NODE_TYPES.ExportNamedDeclaration
? statement.declaration
: statement;
if (declaration !== null && matches(declaration)) {
found.push(declaration);
}
}
return found;
}
/** Whether a node is an interface declaration. */
function isInterface(
node: TSESTree.Node,
): node is TSESTree.TSInterfaceDeclaration {
return node.type === AST_NODE_TYPES.TSInterfaceDeclaration;
}
/** Whether a node is a type alias declaration. */
function isTypeAlias(
node: TSESTree.Node,
): node is TSESTree.TSTypeAliasDeclaration {
return node.type === AST_NODE_TYPES.TSTypeAliasDeclaration;
}
/** Groups nodes by a key and returns the groups with more than one node. */
function duplicateGroups<T>(nodes: T[], keyOf: (node: T) => string): T[][] {
const groups: Map<string, T[]> = Map.groupBy(nodes, keyOf);
return [...groups.values()].filter((group: T[]) => group.length > 1);
}
/** What an interface declares, its `extends` list included. */
function interfaceShape(node: TSESTree.TSInterfaceDeclaration): string {
return `${serialize(node.extends)}&${serialize(node.body)}`;
}
/** An interface's name. */
function interfaceName(node: TSESTree.TSInterfaceDeclaration): string {
return node.id.name;
}
/** What a type alias stands for. */
function typeAliasShape(node: TSESTree.TSTypeAliasDeclaration): string {
return serialize(node.typeAnnotation);
}
/**
* `no-duplicate-interfaces` - two interfaces in one block with the same
* name, which merge silently, or with the same shape, which could be one.
*/
const noDuplicateInterfacesRule: ProjectRule = {
meta: {
type: "suggestion",
docs: {
description:
"Disallow interfaces with the same name or shape in one block",
},
schema: [],
messages: {
sameShape:
"Found multiple interfaces with the same shape, possibly mergeable.",
sameName:
"Found multiple interfaces named '{{name}}', possibly not intended.",
},
},
create(context) {
function check(statements: TSESTree.Node[]): void {
const nodes: TSESTree.TSInterfaceDeclaration[] = declarationsOf(
statements,
isInterface,
);
for (const node of duplicateGroups(nodes, interfaceShape).flat()) {
context.report({ node, messageId: "sameShape" });
}
for (const node of duplicateGroups(nodes, interfaceName).flat()) {
context.report({
node,
messageId: "sameName",
data: { name: node.id.name },
});
}
}
return {
BlockStatement(node: TSESTree.BlockStatement): void {
check(node.body);
},
Program(node: TSESTree.Program): void {
check(node.body);
},
};
},
};
/** `no-duplicate-types` - two type aliases in one block with the same type. */
const noDuplicateTypesRule: ProjectRule = {
meta: {
type: "suggestion",
docs: {
description: "Disallow type aliases with the same type in one block",
},
schema: [],
messages: {
sameShape:
"Found multiple types with the same shape, possibly mergeable.",
},
},
create(context) {
function check(statements: TSESTree.Node[]): void {
const nodes: TSESTree.TSTypeAliasDeclaration[] = declarationsOf(
statements,
isTypeAlias,
);
for (const node of duplicateGroups(nodes, typeAliasShape).flat()) {
context.report({ node, messageId: "sameShape" });
}
}
return {
BlockStatement(node: TSESTree.BlockStatement): void {
check(node.body);
},
Program(node: TSESTree.Program): void {
check(node.body);
},
};
},
};
/** A class member that can carry the `private` keyword. */
type AccessibilityCarrier =
| TSESTree.AccessorProperty
| TSESTree.MethodDefinition
| TSESTree.PropertyDefinition
| TSESTree.TSAbstractAccessorProperty
| TSESTree.TSAbstractMethodDefinition
| TSESTree.TSAbstractPropertyDefinition
| TSESTree.TSParameterProperty;
/**
* `no-modifier-private` - class members are made private with `#`, never the
* `private` keyword, which only TypeScript enforces. A `private constructor`
* has no `#` form and stays allowed.
*/
const noModifierPrivateRule: ProjectRule = {
meta: {
type: "suggestion",
docs: { description: "Disallow the private modifier" },
schema: [],
messages: {
private: "Use a # private name instead of the private modifier.",
},
},
create(context) {
function check(node: AccessibilityCarrier): void {
const isConstructor: boolean =
node.type === AST_NODE_TYPES.MethodDefinition &&
node.kind === "constructor";
if (node.accessibility === "private" && !isConstructor) {
context.report({ node, messageId: "private" });
}
}
return {
AccessorProperty: check,
MethodDefinition: check,
PropertyDefinition: check,
TSAbstractAccessorProperty: check,
TSAbstractMethodDefinition: check,
TSAbstractPropertyDefinition: check,
TSParameterProperty: check,
};
},
};
/** Whether a type is too simple to need an alias: a keyword, literal, or bare name. */
function isSimpleType(node: TSESTree.TypeNode): boolean {
if (SIMPLE_TYPES.has(node.type)) {
return true;
}
if (node.type === AST_NODE_TYPES.TSLiteralType) {
return node.literal.type === AST_NODE_TYPES.Literal;
}
return (
node.type === AST_NODE_TYPES.TSTypeReference &&
node.typeName.type === AST_NODE_TYPES.Identifier &&
node.typeArguments === undefined
);
}
/** `no-useless-type` - a type alias for a keyword, literal, or bare type name. */
const noUselessTypeRule: ProjectRule = {
meta: {
type: "suggestion",
docs: { description: "Disallow type aliases too simple to need a name" },
schema: [],
messages: { simple: "The type is too simple to need an alias." },
},
create(context) {
return {
TSTypeAliasDeclaration(node: TSESTree.TSTypeAliasDeclaration): void {
if (isSimpleType(node.typeAnnotation)) {
context.report({ node, messageId: "simple" });
}
},
};
},
};
/** A module specifier read as a path: relative, absolute, or a `#` alias. */ /** A module specifier read as a path: relative, absolute, or a `#` alias. */
const PATH_SPECIFIER_PATTERN: RegExp = /^[./#]/u; const PATH_SPECIFIER_PATTERN: RegExp = /^[./#]/u;
@@ -649,12 +76,7 @@ const PATH_SPECIFIER_PATTERN: RegExp = /^[./#]/u;
* `.mts`, or `.mjs` package subpaths. `.cts`, `.cjs`, `.tsx`, and `.jsx` are * `.mts`, or `.mjs` package subpaths. `.cts`, `.cjs`, `.tsx`, and `.jsx` are
* not among them. * not among them.
*/ */
const SCRIPT_EXTENSIONS: ReadonlySet<string> = new Set([ const SCRIPT_EXTENSIONS: ReadonlySet<string> = new Set([".ts", ".js", ".mts", ".mjs"]);
".ts",
".js",
".mts",
".mjs",
]);
/** /**
* Whether `source` names an asset rather than a script module: a query string * Whether `source` names an asset rather than a script module: a query string
@@ -674,11 +96,7 @@ function isAssetSource(source: string): boolean {
} }
} }
const lastSegment: string = segments.at(-1) ?? ""; const lastSegment: string = segments.at(-1) ?? "";
if ( if (lastSegment === "." || lastSegment === ".." || !lastSegment.includes(".")) {
lastSegment === "." ||
lastSegment === ".." ||
!lastSegment.includes(".")
) {
return false; return false;
} }
const extension: string = lastSegment.slice(lastSegment.lastIndexOf(".")); const extension: string = lastSegment.slice(lastSegment.lastIndexOf("."));
@@ -686,7 +104,7 @@ function isAssetSource(source: string): boolean {
} }
/** /**
* `no-asset-imports` - rejects importing anything but a script module: a * `no-asset-imports` — rejects importing anything but a script module: a
* source path, static or a dynamic `import()` with a string literal, ending in * source path, static or a dynamic `import()` with a string literal, ending in
* an extension other than `.ts`, `.js`, `.mts`, or `.mjs` (`.css`, `.json`, * an extension other than `.ts`, `.js`, `.mts`, or `.mjs` (`.css`, `.json`,
* `.svg`, `.jsx`, `.tsx`, `.cjs`) or carrying a query string (`?raw`, `?url`), * `.svg`, `.jsx`, `.tsx`, `.cjs`) or carrying a query string (`?raw`, `?url`),
@@ -699,10 +117,7 @@ function isAssetSource(source: string): boolean {
const noAssetImportsRule: ProjectRule = { const noAssetImportsRule: ProjectRule = {
meta: { meta: {
type: "problem", type: "problem",
docs: { docs: { description: "Disallow importing assets instead of .ts, .js, .mts, or .mjs modules" },
description:
"Disallow importing assets instead of .ts, .js, .mts, or .mjs modules",
},
schema: [], schema: [],
messages: { messages: {
extension: "Only .ts, .js, .mts and .mjs modules may be imported.", extension: "Only .ts, .js, .mts and .mjs modules may be imported.",
@@ -734,10 +149,7 @@ const noAssetImportsRule: ProjectRule = {
ExportNamedDeclaration: checkDeclaration, ExportNamedDeclaration: checkDeclaration,
ExportAllDeclaration: checkDeclaration, ExportAllDeclaration: checkDeclaration,
ImportExpression(node: TSESTree.ImportExpression): void { ImportExpression(node: TSESTree.ImportExpression): void {
if ( if (node.source.type === AST_NODE_TYPES.Literal && typeof node.source.value === "string") {
node.source.type === AST_NODE_TYPES.Literal &&
typeof node.source.value === "string"
) {
checkSource(node.source); checkSource(node.source);
} }
if (node.options !== null) { if (node.options !== null) {
@@ -749,9 +161,9 @@ const noAssetImportsRule: ProjectRule = {
}; };
/** /**
* This repository's changes to the Oxlint categories in `vite.config.ts`, * This repository's own rule list, spread by `vite.config.ts`: rules that
* which turn every non-nursery category on: its own rules, the category * sit outside the Oxlint categories, plus the template's extras. Built-in
* rules it turns off, and options that differ from a rule's defaults. * Oxlint rule ids sit here too, so `vite.config.ts` lists no rule by name.
*/ */
const rules: DummyRuleMap = { const rules: DummyRuleMap = {
// The explicit-types template's `camelcase` stand-in: no `_` inside a name // The explicit-types template's `camelcase` stand-in: no `_` inside a name
@@ -760,13 +172,33 @@ const rules: DummyRuleMap = {
"id-match": [ "id-match": [
"error", "error",
"^_*[^_]*_*$|^[^a-z]*$", "^_*[^_]*_*$|^[^a-z]*$",
{ { properties: false, classFields: false, onlyDeclarations: false, ignoreDestructuring: true },
properties: false,
classFields: false,
onlyDeclarations: false,
ignoreDestructuring: true,
},
], ],
// Rules outside the categories.
"no-array-constructor": "error",
"no-case-declarations": "error",
"no-empty": "error",
"no-fallthrough": "error",
"no-inner-declarations": "error",
"no-prototype-builtins": "error",
"no-redeclare": "error",
"no-regex-spaces": "error",
"no-var": "error",
"prefer-const": "error",
"require-await": "error",
"require-yield": "error",
"typescript/adjacent-overload-signatures": "error",
"typescript/ban-ts-comment": "error",
"typescript/no-empty-interface": "error",
"typescript/no-empty-object-type": "error",
"typescript/no-explicit-any": "error",
"typescript/no-namespace": "error",
"typescript/no-non-null-asserted-optional-chain": "error",
"typescript/no-unsafe-function-type": "error",
"typescript/no-wrapper-object-types": "error",
"typescript/prefer-as-const": "error",
"typescript/prefer-namespace-keyword": "error",
"typescript/triple-slash-reference": "error",
// On Node, these come from an explicit `node:` import instead of the global scope. // On Node, these come from an explicit `node:` import instead of the global scope.
"no-restricted-globals": [ "no-restricted-globals": [
"error", "error",
@@ -777,162 +209,47 @@ const rules: DummyRuleMap = {
"setImmediate", "setImmediate",
"clearImmediate", "clearImmediate",
], ],
// Single capital type parameters, which explicit-types requires, may be one letter. // The explicit-types template's extras.
"id-length": ["error", { exceptionPatterns: ["^[A-Z]$"] }], "import/no-cycle": "error",
// Option tweaks. // `../` is banned in every file; anything above a file needs a `#` alias.
"one-var": ["error", "never"], "import/no-relative-parent-imports": "error",
"no-use-before-define": ["error", { functions: false }], "typescript/consistent-type-imports": "error",
"func-style": ["error", "declaration", { allowArrowFunctions: true }], "typescript/no-import-type-side-effects": "error",
// Each limit is the smallest value the current code passes. "typescript/no-non-null-assertion": "error",
complexity: ["error", 26], // No disable comments at all.
"max-depth": ["error", 6],
"max-lines": [
"error",
{ max: 2048, skipBlankLines: false, skipComments: false },
],
"max-lines-per-function": ["error", 124],
"max-params": ["error", 4],
"max-statements": ["error", 32],
"import/max-dependencies": ["error", { max: 13 }],
"unicorn/max-nested-calls": ["error", { max: 4 }],
// No lint suppression and only `.ts` imports, as in the plugin template.
"project/no-disable-comments": "error", "project/no-disable-comments": "error",
"project/no-asset-imports": "error", "project/no-asset-imports": "error",
// Ports of the hugoalh `recommended` rules Oxlint lacks, and ASCII-only source. "unicorn/no-abusive-eslint-disable": "error",
"project/prefer-ascii": "error", // Size and complexity limits match Deno's: this repo's `deno lint` ran the
"project/no-duplicate-typeofs": "error", // `recommended` set with no config file, so no size or complexity rule
"project/no-empty-yield": "error", // applied and none applies here. Each Oxlint limit rule, from a category or
"project/no-nan": "error", // not, is off:
"project/no-unsafe-number": "error", // - `complexity`: Deno had no `max-complexity`.
"project/no-useless-continue": "error", // - `max-lines`: Deno had no `max-file-lines`.
"project/no-duplicate-interfaces": "error", // - `max-params`: Deno had no `max-params`.
"project/no-duplicate-types": "error", // - `id-length`: Deno had no `max-identifier-length`.
"project/no-modifier-private": "error", // - `no-nested-ternary`: Deno had no `max-nest-ternaries`.
"project/no-useless-type": "error", // - `max-lines-per-function`, `max-classes-per-file`, `max-depth`,
// Off, collides with a repo or plugin rule, Oxfmt, or another category rule: // `max-nested-callbacks`, `max-statements`, `import/max-dependencies`,
// Collides with `#private`: members are public unless marked so. // `unicorn/max-nested-calls`: Deno had none of these.
"typescript/explicit-member-accessibility": "off", complexity: "off",
// Collides with `typescript/prefer-readonly-parameter-types` being off. "max-lines": "off",
"typescript/prefer-readonly": "off", "max-params": "off",
// Collides with Node's and the web's mutable types (`Response`, `Stats`). "id-length": "off",
"no-nested-ternary": "off",
"max-lines-per-function": "off",
"max-classes-per-file": "off",
"max-depth": "off",
"max-nested-callbacks": "off",
"max-statements": "off",
"import/max-dependencies": "off",
"unicorn/max-nested-calls": "off",
// Pedantic, but Node's and the web's own types (`Response`, `Stats`,
// `RequestInit`) are mutable, so no parameter of theirs can pass; the
// explicit-types template and the app repos turn it off too.
"typescript/prefer-readonly-parameter-types": "off", "typescript/prefer-readonly-parameter-types": "off",
// Collides with explicit-types `no-utility-types`, which bans `Record`.
"typescript/consistent-indexed-object-style": "off",
// Collides with explicitly annotated declarations.
"typescript/no-inferrable-types": "off",
// Collides with import-structure `enforce-import-order`.
"sort-imports": "off",
// Collides with import-structure `enforce-mod-file` barrels.
"oxc/no-barrel-file": "off",
// Collides with exporting each declaration where it stands.
"import/group-exports": "off",
// Collides with exporting each declaration where it stands.
"import/exports-last": "off",
// Collides with `import/no-default-export`.
"import/prefer-default-export": "off",
// Collides with `unicorn/prefer-ternary`.
"no-ternary": "off",
// Collides with `require-await` and `promise-function-async`.
"oxc/no-async-await": "off",
// Collides with `typescript/prefer-optional-chain`.
"oxc/no-optional-chaining": "off",
// Collides with file mode checks such as `mode & 0o077`.
"no-bitwise": "off",
// Collides with explicit-types `no-optional-null`, which makes `undefined` the absent value.
"no-undefined": "off",
// Collides with `typescript/no-floating-promises`, which `void` satisfies.
"no-void": "off",
// Collides with JSON and Node APIs, which return `null`.
"unicorn/no-null": "off",
// Collides with `import/no-default-export`.
"import/no-named-export": "off",
// Collides with `typescript/consistent-type-imports`.
"import/consistent-type-specifier-style": "off",
// Collides with Oxfmt, which lowercases hex digits back.
"unicorn/number-literal-case": "off",
// Node code, everywhere: this action runs on Node.
// Node built-ins are the action's runtime.
"import/no-nodejs-modules": "off",
// Command-line entry points set their exit status.
"unicorn/no-process-exit": "off",
// The action reports to the job log through the console.
"no-console": "off",
// Sequential awaits are intentional; workarounds cost more than they save.
"no-await-in-loop": "off",
// Not type-aware; TypeScript's `noImplicitReturns` covers it.
"consistent-return": "off",
// Misfires on complete switches, like `consistent-return`; TypeScript covers it.
"typescript/consistent-return": "off",
// TypeScript's type checking covers exhaustive switches.
"typescript/switch-exhaustiveness-check": "off",
// TypeScript checks completeness; a forced `default:` hides missing cases.
"default-case": "off",
// Off, too much churn:
// Literal numbers read better than a constant per use.
"no-magic-numbers": "off",
// Keys follow meaning, not the alphabet.
"sort-keys": "off",
// Comments may start with code or lowercase identifiers.
"capitalized-comments": "off",
// explicit-types `require-return-type` covers return types.
"typescript/explicit-function-return-type": "off",
// explicit-types `require-return-type` covers return types.
"typescript/explicit-module-boundary-types": "off",
// Empty callbacks are legitimate no-ops.
"no-empty-function": "off",
// Methods may not need `this`.
"class-methods-use-this": "off",
// Braces only where a case declares.
"unicorn/switch-case-braces": "off",
// Plain property reads are fine.
"prefer-destructuring": "off",
// Object rest and spread are idiomatic.
"oxc/no-rest-spread-properties": "off",
// Short numbers need no separators.
"unicorn/numeric-separators-style": "off",
// `continue` keeps loop bodies flat.
"no-continue": "off",
}; };
/** Node code (`vite.config.ts` and `scripts/`): the first `projectOverrides` entry. */
const nodeRules: DummyRuleMap = {
// Vite and the Oxlint plugin host read a default export.
"import/no-default-export": "off",
};
/**
* The whole `overrides` array of `vite.config.ts`: the Node code entry first,
* then each per-file exception, each with a comment saying why. Later entries
* win over earlier ones, and all of them over `rules`.
*/
export const projectOverrides: OxlintOverride[] = [
{
files: ["vite.config.ts", "scripts/**"],
rules: nodeRules,
},
// exitCode must return the promise it marks handled; an async wrapper's
// promise would reject unhandled before callers await it.
{
files: ["src/processes/child.ts"],
rules: { "typescript/promise-function-async": "off" },
},
// Posted Gitea text shows emoji verdict marks and a middle dot.
{
files: [
"src/post/post.ts",
"src/post/post.test.ts",
"src/profiles/profiles.ts",
"src/profiles/profiles.test.ts",
],
rules: { "project/prefer-ascii": "off" },
},
// The workflow test checks literal Gitea Actions `${{ }}` expressions.
{
files: ["tests/workflow.test.ts"],
rules: { "no-template-curly-in-string": "off" },
},
];
/** /**
* The repo-local plugin, namespace `project`: its own rules, enabled as * The repo-local plugin, namespace `project`: its own rules, enabled as
* `project/<rule>`, and `configs.project`, the rule list above. * `project/<rule>`, and `configs.project`, the rule list above.
@@ -942,16 +259,6 @@ const plugin = {
rules: { rules: {
"no-disable-comments": noDisableCommentsRule, "no-disable-comments": noDisableCommentsRule,
"no-asset-imports": noAssetImportsRule, "no-asset-imports": noAssetImportsRule,
"prefer-ascii": preferAsciiRule,
"no-duplicate-typeofs": noDuplicateTypeofsRule,
"no-empty-yield": noEmptyYieldRule,
"no-nan": noNanRule,
"no-unsafe-number": noUnsafeNumberRule,
"no-useless-continue": noUselessContinueRule,
"no-duplicate-interfaces": noDuplicateInterfacesRule,
"no-duplicate-types": noDuplicateTypesRule,
"no-modifier-private": noModifierPrivateRule,
"no-useless-type": noUselessTypeRule,
}, },
configs: { project: { rules } }, configs: { project: { rules } },
}; };
+64 -98
View File
@@ -1,11 +1,4 @@
import { import { mkdir, readFile, rm, stat, symlink, writeFile } from "node:fs/promises";
mkdir,
readFile,
rm,
stat,
symlink,
writeFile,
} from "node:fs/promises";
import { expect, test } from "vite-plus/test"; import { expect, test } from "vite-plus/test";
import { currentGid, currentUid, IS_WINDOWS, makeTempDir } from "#testing"; import { currentGid, currentUid, IS_WINDOWS, makeTempDir } from "#testing";
@@ -23,19 +16,14 @@ test("retries once after an invalid refresh token", async () => {
let attempts = 0; let attempts = 0;
let relogins = 0; let relogins = 0;
const result = await retryInvalidToken( const result = await retryInvalidToken(
async () => { () =>
const resolved = await Promise.resolve({ Promise.resolve({
code: 1, code: 1,
error: error: attempts++ === 0 ? "ERROR: invalid_refresh_token" : "still failed",
(attempts += 1) === 1 }),
? "ERROR: invalid_refresh_token" () => {
: "still failed", relogins++;
}); return Promise.resolve();
return resolved;
},
async () => {
relogins += 1;
await Promise.resolve();
}, },
); );
@@ -50,17 +38,16 @@ test("does not retry an unrelated failure", async () => {
let attempts = 0; let attempts = 0;
let relogins = 0; let relogins = 0;
await retryInvalidToken( await retryInvalidToken(
async () => { () => {
attempts += 1; attempts++;
const resolved = await Promise.resolve({ return Promise.resolve({
code: 1, code: 1,
error: "rate limited", error: "rate limited",
}); });
return resolved;
}, },
async () => { () => {
relogins += 1; relogins++;
await Promise.resolve(); return Promise.resolve();
}, },
); );
@@ -98,16 +85,14 @@ test("re-logs in after the job 9837 revoked-session stderr", async () => {
let relogins = 0; let relogins = 0;
let attempts = 0; let attempts = 0;
const result = await retryInvalidToken( const result = await retryInvalidToken(
async () => { () =>
const resolved = await Promise.resolve({ Promise.resolve({
code: (attempts += 1) > 1 ? 0 : 1, code: attempts++ > 0 ? 0 : 1,
error: attempts === 1 ? REVOKED_CODEX.join("\n") : "", error: attempts === 1 ? REVOKED_CODEX.join("\n") : "",
}); }),
return resolved; () => {
}, relogins++;
async () => { return Promise.resolve();
relogins += 1;
await Promise.resolve();
}, },
); );
@@ -121,19 +106,15 @@ test("recognizes a rejected Claude OAuth token", () => {
expect( expect(
isClaudeAuthFailure({ isClaudeAuthFailure({
apiErrorStatus: 401, apiErrorStatus: 401,
result: result: "Failed to authenticate. API Error: 401 OAuth access token is invalid.",
"Failed to authenticate. API Error: 401 OAuth access token is invalid.",
}), }),
).toBe(true); ).toBe(true);
expect( expect(
isClaudeAuthFailure({ isClaudeAuthFailure({
result: result: "OAuth token has expired. Please obtain a new token or refresh your existing token.",
"OAuth token has expired. Please obtain a new token or refresh your existing token.",
}), }),
).toBe(true); ).toBe(true);
expect( expect(isClaudeAuthFailure({ apiErrorStatus: 429, result: "API Error: 429" })).toBe(false);
isClaudeAuthFailure({ apiErrorStatus: 429, result: "API Error: 429" }),
).toBe(false);
}); });
test("selects API-key login only for a configured Codex token", () => { test("selects API-key login only for a configured Codex token", () => {
@@ -152,62 +133,47 @@ const AUTH_TOKENS = {
}; };
const AUTH = JSON.stringify({ auth_mode: "chatgpt", tokens: AUTH_TOKENS }); const AUTH = JSON.stringify({ auth_mode: "chatgpt", tokens: AUTH_TOKENS });
test.skipIf(IS_WINDOWS)( test.skipIf(IS_WINDOWS)("stages and persists only a regular private Codex login", async () => {
"stages and persists only a regular private Codex login", const root = await makeTempDir();
async () => { try {
const root = await makeTempDir(); const canonical = `${root}/persistent/auth.json`;
try { await mkdir(`${root}/persistent`);
const canonical = `${root}/persistent/auth.json`; await writeFile(canonical, AUTH, { mode: 0o600 });
await mkdir(`${root}/persistent`); const home = `${root}/profile`;
await writeFile(canonical, AUTH, { mode: 0o600 }); await mkdir(home);
const home = `${root}/profile`;
await mkdir(home);
const staged = await stageCodexAuth( const staged = await stageCodexAuth(canonical, home, currentUid(), currentGid());
canonical, expect(await readFile(staged, "utf8")).toStrictEqual(AUTH);
home, expect((await stat(staged)).mode & 0o777).toBe(0o600);
currentUid(),
currentGid(),
);
expect(await readFile(staged, "utf8")).toStrictEqual(AUTH);
const stagedStat = await stat(staged);
expect(stagedStat.mode & 0o777).toBe(0o600);
const refreshed = JSON.stringify({ const refreshed = JSON.stringify({
auth_mode: "chatgpt", auth_mode: "chatgpt",
tokens: { ...AUTH_TOKENS, access_token: "refreshed" }, tokens: { ...AUTH_TOKENS, access_token: "refreshed" },
}); });
await writeFile(staged, refreshed); await writeFile(staged, refreshed);
await persistCodexAuth(staged, canonical); await persistCodexAuth(staged, canonical);
expect(await readFile(canonical, "utf8")).toStrictEqual(refreshed); expect(await readFile(canonical, "utf8")).toStrictEqual(refreshed);
const canonicalStat = await stat(canonical); expect((await stat(canonical)).mode & 0o777).toBe(0o600);
expect(canonicalStat.mode & 0o777).toBe(0o600); } finally {
} finally { await rm(root, { recursive: true });
await rm(root, { recursive: true }); }
} });
},
);
test.skipIf(IS_WINDOWS)( test.skipIf(IS_WINDOWS)("rejects a symlink or malformed Codex login", async () => {
"rejects a symlink or malformed Codex login", const root = await makeTempDir();
async () => { try {
const root = await makeTempDir(); const canonical = `${root}/auth.json`;
try { const malformed = `${root}/malformed.json`;
const canonical = `${root}/auth.json`; const linked = `${root}/linked.json`;
const malformed = `${root}/malformed.json`; await writeFile(canonical, AUTH, { mode: 0o600 });
const linked = `${root}/linked.json`; await writeFile(malformed, '{"tokens":{}}', { mode: 0o600 });
await writeFile(canonical, AUTH, { mode: 0o600 }); await symlink(canonical, linked);
await writeFile(malformed, '{"tokens":{}}', { mode: 0o600 });
await symlink(canonical, linked);
await expect(persistCodexAuth(linked, canonical)).rejects.toThrow( await expect(() => persistCodexAuth(linked, canonical)).rejects.toThrow("regular file");
"regular file", await expect(() => persistCodexAuth(malformed, canonical)).rejects.toThrow(
); "invalid Codex login",
await expect(persistCodexAuth(malformed, canonical)).rejects.toThrow( );
"invalid Codex login", } finally {
); await rm(root, { recursive: true });
} finally { }
await rm(root, { recursive: true }); });
}
},
);
+16 -28
View File
@@ -10,9 +10,9 @@ import {
rm, rm,
writeFile, writeFile,
} from "node:fs/promises"; } from "node:fs/promises";
import nodePath from "node:path"; import { dirname, join } from "node:path";
import { field, isNotFound, isObject } from "#common"; import { isNotFound, isObject } from "#common";
interface CodexApiKey { interface CodexApiKey {
kind: "api-key"; kind: "api-key";
@@ -26,9 +26,7 @@ interface CodexPersistent {
export type CodexAuthentication = CodexApiKey | CodexPersistent; export type CodexAuthentication = CodexApiKey | CodexPersistent;
export function codexAuthentication(token?: string): CodexAuthentication { export function codexAuthentication(token?: string): CodexAuthentication {
return token === undefined return token === undefined ? { kind: "persistent" } : { kind: "api-key", token };
? { kind: "persistent" }
: { kind: "api-key", token };
} }
// Codex logs revoked, expired, or reused ChatGPT sign-ins and rejected API keys // Codex logs revoked, expired, or reused ChatGPT sign-ins and rejected API keys
@@ -85,23 +83,20 @@ async function readCodexAuth(path: string): Promise<string> {
throw new Error("Codex login must be private"); throw new Error("Codex login must be private");
} }
const text = await readFile(path, "utf8"); const text = await readFile(path, "utf8");
let value: unknown = null; let value: unknown;
try { try {
value = JSON.parse(text); value = JSON.parse(text);
} catch { } catch {
throw new Error("invalid Codex login"); throw new Error("invalid Codex login");
} }
const authMode = field(value, "auth_mode"); const tokens = isObject(value) ? value["tokens"] : undefined;
const tokens = field(value, "tokens");
if ( if (
typeof authMode !== "string" || !isObject(value) ||
authMode === "" || typeof value["auth_mode"] !== "string" ||
value["auth_mode"] === "" ||
!isObject(tokens) || !isObject(tokens) ||
!["access_token", "refresh_token", "id_token", "account_id"].every( !["access_token", "refresh_token", "id_token", "account_id"].every(
(name) => { (name) => typeof tokens[name] === "string" && tokens[name] !== "",
const token = field(tokens, name);
return typeof token === "string" && token !== "";
},
) )
) { ) {
throw new Error("invalid Codex login"); throw new Error("invalid Codex login");
@@ -115,39 +110,32 @@ export async function stageCodexAuth(
uid: number, uid: number,
gid: number, gid: number,
): Promise<string> { ): Promise<string> {
const codexHome = nodePath.join(profileHome, ".codex"); const codexHome = join(profileHome, ".codex");
await mkdir(codexHome, { recursive: true, mode: 0o700 }); await mkdir(codexHome, { recursive: true, mode: 0o700 });
await chmod(codexHome, 0o700); await chmod(codexHome, 0o700);
await chown(codexHome, uid, gid); await chown(codexHome, uid, gid);
const stagedPath = nodePath.join(codexHome, "auth.json"); const stagedPath = join(codexHome, "auth.json");
try { try {
await writeFile(stagedPath, await readCodexAuth(canonicalPath), { await writeFile(stagedPath, await readCodexAuth(canonicalPath), { mode: 0o600 });
mode: 0o600,
});
await chmod(stagedPath, 0o600); await chmod(stagedPath, 0o600);
await chown(stagedPath, uid, gid); await chown(stagedPath, uid, gid);
} catch (error) { } catch (error) {
if (!isNotFound(error)) { if (!isNotFound(error)) throw error;
throw error;
}
} }
return stagedPath; return stagedPath;
} }
// Creates an empty private file under a fresh name. // Creates an empty private file under a fresh name.
async function makeTempFile(directory: string): Promise<string> { async function makeTempFile(directory: string): Promise<string> {
const path = nodePath.join(directory, `.tmp-${randomUUID()}`); const path = join(directory, `.tmp-${randomUUID()}`);
const handle = await open(path, "wx", 0o600); const handle = await open(path, "wx", 0o600);
await handle.close(); await handle.close();
return path; return path;
} }
export async function persistCodexAuth( export async function persistCodexAuth(stagedPath: string, canonicalPath: string): Promise<void> {
stagedPath: string,
canonicalPath: string,
): Promise<void> {
const text = await readCodexAuth(stagedPath); const text = await readCodexAuth(stagedPath);
const directory = nodePath.dirname(canonicalPath); const directory = dirname(canonicalPath);
await mkdir(directory, { recursive: true, mode: 0o700 }); await mkdir(directory, { recursive: true, mode: 0o700 });
const temporary = await makeTempFile(directory); const temporary = await makeTempFile(directory);
try { try {
+1 -5
View File
@@ -8,11 +8,7 @@ export {
retryInvalidToken, retryInvalidToken,
stageCodexAuth, stageCodexAuth,
} from "./auth.ts"; } from "./auth.ts";
export type { export type { ClaudeFailureFields, CodexAuthentication, CommandResult } from "./auth.ts";
ClaudeFailureFields,
CodexAuthentication,
CommandResult,
} from "./auth.ts";
export { export {
collectOpenCodeOutput, collectOpenCodeOutput,
openCodeArgs, openCodeArgs,
+6 -13
View File
@@ -10,9 +10,7 @@ import {
} from "./opencode.ts"; } from "./opencode.ts";
test("builds a non-interactive auto-approved OpenCode command", () => { test("builds a non-interactive auto-approved OpenCode command", () => {
expect( expect(openCodeArgs("openrouter/qwen/qwen3.8-27b", "Review this")).toStrictEqual([
openCodeArgs("openrouter/qwen/qwen3.8-27b", "Review this"),
).toStrictEqual([
"run", "run",
"--format", "--format",
"json", "json",
@@ -72,10 +70,7 @@ test("streams OpenCode output while collecting it", async () => {
}, },
); );
expect(result).toStrictEqual({ expect(result).toStrictEqual({ stdout: "first\nsecond\n", stderr: "warning\n" });
stdout: "first\nsecond\n",
stderr: "warning\n",
});
expect(shown).toStrictEqual(["out:first\n", "err:warning\n", "out:second\n"]); expect(shown).toStrictEqual(["out:first\n", "err:warning\n", "out:second\n"]);
}); });
@@ -99,14 +94,12 @@ test("reports a rejected OpenRouter key as a sign-in failure", () => {
assert.instanceOf(error, AgentAuthError); assert.instanceOf(error, AgentAuthError);
expect(error.message).toBe("opencode sign-in failed"); expect(error.message).toBe("opencode sign-in failed");
assert.instanceOf(error.cause, Error); assert.instanceOf(error.cause, Error);
expect(error.cause.message).toBe( expect(error.cause.message).toBe("opencode APIError (API error 401): User not found.");
"opencode APIError (API error 401): User not found.",
);
}); });
test("surfaces an OpenCode error event instead of empty output", () => { test("surfaces an OpenCode error event instead of empty output", () => {
expect(() => expect(() => parseOpenCodeEvents(openRouterError(429, "Rate limit exceeded"))).toThrow(
parseOpenCodeEvents(openRouterError(429, "Rate limit exceeded")), "API error 429",
).toThrow("API error 429"); );
expect(openCodeError('{"type":"text","part":{"text":"ok"}}')).toBeNull(); expect(openCodeError('{"type":"text","part":{"text":"ok"}}')).toBeNull();
}); });
+15 -25
View File
@@ -1,4 +1,4 @@
import { field, isObject } from "#common"; import { isObject } from "#common";
import { AgentAuthError } from "#profiles"; import { AgentAuthError } from "#profiles";
export function openCodeArgs(model: string, prompt: string): string[] { export function openCodeArgs(model: string, prompt: string): string[] {
@@ -49,23 +49,20 @@ export async function collectOpenCodeOutput(
export function openCodeError(output: string): Error | null { export function openCodeError(output: string): Error | null {
let failure: Error | null = null; let failure: Error | null = null;
for (const line of output.split("\n")) { for (const line of output.split("\n")) {
if (line.trim() === "") { if (line.trim() === "") continue;
continue; let event: unknown;
}
let event: unknown = null;
try { try {
event = JSON.parse(line); event = JSON.parse(line);
} catch { } catch {
continue; continue;
} }
const error = field(event, "error"); if (!isObject(event)) continue;
if (field(event, "type") !== "error" || !isObject(error)) { const { type, error } = event;
if (type !== "error" || !isObject(error)) {
continue; continue;
} }
const name = field(error, "name"); const { name, data } = error;
const data = field(error, "data"); const { message, statusCode } = isObject(data) ? data : {};
const message = field(data, "message");
const statusCode = field(data, "statusCode");
const detail = `opencode ${typeof name === "string" ? name : "error"}${ const detail = `opencode ${typeof name === "string" ? name : "error"}${
typeof statusCode === "number" ? ` (API error ${statusCode})` : "" typeof statusCode === "number" ? ` (API error ${statusCode})` : ""
}: ${typeof message === "string" ? message : "unknown error"}`; }: ${typeof message === "string" ? message : "unknown error"}`;
@@ -82,23 +79,16 @@ export function openCodeError(output: string): Error | null {
export function parseOpenCodeEvents(output: string): string { export function parseOpenCodeEvents(output: string): string {
let result: string | null = null; let result: string | null = null;
for (const line of output.split("\n")) { for (const line of output.split("\n")) {
if (line.trim() === "") { if (line.trim() === "") continue;
continue;
}
const event: unknown = JSON.parse(line); const event: unknown = JSON.parse(line);
const part = field(event, "part"); if (!isObject(event)) continue;
if (field(event, "type") !== "text" || !isObject(part)) { const { type, part } = event;
continue; if (type !== "text" || !isObject(part)) continue;
} const { text } = part;
const text = field(part, "text"); if (typeof text === "string" && text.trim() !== "") result = text;
if (typeof text === "string" && text.trim() !== "") {
result = text;
}
} }
if (result === null) { if (result === null) {
throw ( throw openCodeError(output) ?? new Error("OpenCode produced no text output");
openCodeError(output) ?? new Error("OpenCode produced no text output")
);
} }
return result; return result;
} }
+2 -1
View File
@@ -1,3 +1,4 @@
// Helpers every phase shares: error and JSON value checks. // Helpers every phase shares: error and JSON value checks.
export { isNotFound } from "./errors.ts"; export { isNotFound } from "./errors.ts";
export { field, isMapping, isObject } from "./json.ts"; export { isMapping, isObject } from "./json.ts";
export type { JsonObject } from "./json.ts";
-25
View File
@@ -1,25 +0,0 @@
import { expect, test } from "vite-plus/test";
import { field, isMapping, isObject } from "./json.ts";
test("reads a named field of a parsed object", () => {
const value: unknown = JSON.parse(
'{"login":"bot","user":{"login":"nested"}}',
);
expect(field(value, "login")).toBe("bot");
expect(field(field(value, "user"), "login")).toBe("nested");
expect(field(value, "missing")).toBeUndefined();
});
test("reads no field of a value that is not an object", () => {
for (const value of [null, undefined, "text", 1, true]) {
expect(field(value, "login")).toBeUndefined();
}
});
test("counts arrays as objects but not as mappings", () => {
expect(isObject([])).toBe(true);
expect(isMapping([])).toBe(false);
expect(isMapping({})).toBe(true);
expect(field(["first"], "0")).toBe("first");
});
+5 -12
View File
@@ -1,19 +1,12 @@
// Checks and field reads for values parsed from JSON, which arrive as // Type guards for values read from JSON, which arrive as `unknown`.
// `unknown`. Callers read the fields they know by name into their own export type JsonObject = NodeJS.Dict<unknown>;
// declared interfaces.
// Any non-null object, arrays included. // Any non-null object, arrays included: reading a missing key yields undefined.
export function isObject(value: unknown): value is object { export function isObject(value: unknown): value is JsonObject {
return typeof value === "object" && value !== null; return typeof value === "object" && value !== null;
} }
// A plain mapping, which an array is not. // A plain mapping, which an array is not.
export function isMapping(value: unknown): value is object { export function isMapping(value: unknown): value is JsonObject {
return isObject(value) && !Array.isArray(value); return isObject(value) && !Array.isArray(value);
} }
// The named field of an object, or undefined for a missing field or a value
// that is not an object.
export function field(value: unknown, name: string): unknown {
return isObject(value) ? Reflect.get(value, name) : undefined;
}
+1 -3
View File
@@ -8,9 +8,7 @@ export { type Fetcher, type PostContext, postRuntime } from "./post.ts";
function required(name: string): string { function required(name: string): string {
const value = process.env[name]; const value = process.env[name];
if (value === undefined || value === "") { if (value === undefined || value === "") throw new Error(`${name} is not set`);
throw new Error(`${name} is not set`);
}
return value; return value;
} }
+46 -73
View File
@@ -45,15 +45,9 @@ async function writeArtifacts(
review?: string, review?: string,
anchors?: unknown, anchors?: unknown,
): Promise<void> { ): Promise<void> {
if (!outcome.ok) { if (!outcome.ok) return;
return; if (review !== undefined) await writePrivate(outcome.reviewPath, review);
} if (anchors !== undefined) await writePrivate(outcome.anchorsPath, JSON.stringify(anchors));
if (review !== undefined) {
await writePrivate(outcome.reviewPath, review);
}
if (anchors !== undefined) {
await writePrivate(outcome.anchorsPath, JSON.stringify(anchors));
}
} }
function manifestFor(runtimeDir: string, profileHome: string): RuntimeManifest { function manifestFor(runtimeDir: string, profileHome: string): RuntimeManifest {
@@ -65,7 +59,7 @@ function manifestFor(runtimeDir: string, profileHome: string): RuntimeManifest {
profiles: [ profiles: [
{ {
index: 0, index: 0,
type: "CLAUDE", type: "claude",
model: "test", model: "test",
uid: currentUid(), uid: currentUid(),
gid: currentGid(), gid: currentGid(),
@@ -89,7 +83,7 @@ async function fixture(
const outcome: RuntimeOutcome = source.ok const outcome: RuntimeOutcome = source.ok
? { ? {
...source, ...source,
profile: { type: "CODEX", model: "gpt-test" }, profile: { type: "codex", model: "gpt-test" },
reviewPath: `${profileHome}/review.md`, reviewPath: `${profileHome}/review.md`,
anchorsPath: `${profileHome}/anchors.json`, anchorsPath: `${profileHome}/anchors.json`,
} }
@@ -112,9 +106,7 @@ const missing = async (path: string): Promise<boolean> => {
await stat(path); await stat(path);
return false; return false;
} catch (error) { } catch (error) {
if (isNotFound(error)) { if (isNotFound(error)) return true;
return true;
}
throw error; throw error;
} }
}; };
@@ -126,10 +118,9 @@ function requestBody(init?: RequestInit): unknown {
// A fake Gitea that records each request body and answers with `status`. // A fake Gitea that records each request body and answers with `status`.
function recordingFetch(bodies: unknown[], status = 201): Fetcher { function recordingFetch(bodies: unknown[], status = 201): Fetcher {
return async (_url, init) => { return (_url, init) => {
bodies.push(requestBody(init)); bodies.push(requestBody(init));
const resolved = await Promise.resolve(new Response(null, { status })); return Promise.resolve(new Response(null, { status }));
return resolved;
}; };
} }
@@ -137,17 +128,14 @@ test("posts a successful issue result and removes runtime credentials", async ()
const result = await fixture({ ok: true, body: "done" }); const result = await fixture({ ok: true, body: "done" });
const requests: RecordedRequest[] = []; const requests: RecordedRequest[] = [];
await postRuntime(result.manifestPath, context, async (url, init) => { await postRuntime(result.manifestPath, context, (url, init) => {
requests.push({ url, init }); requests.push({ url, init });
const resolved = await Promise.resolve(new Response(null, { status: 201 })); return Promise.resolve(new Response(null, { status: 201 }));
return resolved;
}); });
expect(requests.length).toBe(1); expect(requests.length).toBe(1);
const [request] = requests; const [request] = requests;
expect(request?.url).toStrictEqual( expect(request?.url).toStrictEqual(`${context.apiUrl}/repos/owner/repo/issues/7/comments`);
`${context.apiUrl}/repos/owner/repo/issues/7/comments`,
);
expect(requestBody(request?.init)).toStrictEqual({ expect(requestBody(request?.init)).toStrictEqual({
body: "done\n\n> Profile: `codex` · `gpt-test`", body: "done\n\n> Profile: `codex` · `gpt-test`",
}); });
@@ -159,11 +147,9 @@ test("posts a successful issue result and removes runtime credentials", async ()
}); });
test("retries a rejected inline review without anchors", async () => { test("retries a rejected inline review without anchors", async () => {
const result = await fixture( const result = await fixture({ ok: true, body: "ignored final response" }, "Approved\nReady", [
{ ok: true, body: "ignored final response" }, { path: "run.ts", line: 1, side: "new", body: "Finding" },
"Approved\nReady", ]);
[{ path: "run.ts", line: 1, side: "NEW", body: "Finding" }],
);
const bodies: unknown[] = []; const bodies: unknown[] = [];
await postRuntime( await postRuntime(
@@ -172,12 +158,9 @@ test("retries a rejected inline review without anchors", async () => {
...context, ...context,
eventName: "pull_request", eventName: "pull_request",
}, },
async (_url, init) => { (_url, init) => {
bodies.push(requestBody(init)); bodies.push(requestBody(init));
const resolved = await Promise.resolve( return Promise.resolve(new Response(null, { status: bodies.length === 1 ? 422 : 200 }));
new Response(null, { status: bodies.length === 1 ? 422 : 200 }),
);
return resolved;
}, },
); );
@@ -195,14 +178,14 @@ test("reports each tried profile and keeps the action failed", async () => {
const result = await fixture({ const result = await fixture({
ok: false, ok: false,
failures: [ failures: [
{ type: "CODEX", model: "gpt-test", reason: "SIGN_IN_FAILED" }, { type: "codex", model: "gpt-test", reason: "sign-in failed" },
{ type: "CLAUDE", model: "claude-test", reason: "USAGE_EXHAUSTED" }, { type: "claude", model: "claude-test", reason: "usage exhausted" },
{ type: "OPENCODE", model: "openrouter/test", reason: "FAILED" }, { type: "opencode", model: "openrouter/test", reason: "failed" },
], ],
}); });
const bodies: unknown[] = []; const bodies: unknown[] = [];
await expect( await expect(() =>
postRuntime(result.manifestPath, context, recordingFetch(bodies)), postRuntime(result.manifestPath, context, recordingFetch(bodies)),
).rejects.toThrow("agent phase failed"); ).rejects.toThrow("agent phase failed");
@@ -225,15 +208,15 @@ test("drops failure entries that are not known labels", async () => {
JSON.stringify({ JSON.stringify({
ok: false, ok: false,
failures: [ failures: [
{ type: "CODEX", model: "gpt-test", reason: "token sk-secret leaked" }, { type: "codex", model: "gpt-test", reason: "token sk-secret leaked" },
{ type: "shell", model: "x", reason: "FAILED" }, { type: "shell", model: "x", reason: "failed" },
{ type: "CLAUDE", model: "claude-test", reason: "SIGN_IN_FAILED" }, { type: "claude", model: "claude-test", reason: "sign-in failed" },
], ],
}), }),
); );
const bodies: unknown[] = []; const bodies: unknown[] = [];
await expect( await expect(() =>
postRuntime(result.manifestPath, context, recordingFetch(bodies)), postRuntime(result.manifestPath, context, recordingFetch(bodies)),
).rejects.toThrow("agent phase failed"); ).rejects.toThrow("agent phase failed");
@@ -249,7 +232,7 @@ test("reports a generic failure when the runner wrote no outcome", async () => {
await rm(result.outcomeFile); await rm(result.outcomeFile);
const bodies: unknown[] = []; const bodies: unknown[] = [];
await expect( await expect(() =>
postRuntime(result.manifestPath, context, recordingFetch(bodies)), postRuntime(result.manifestPath, context, recordingFetch(bodies)),
).rejects.toThrow("agent phase failed"); ).rejects.toThrow("agent phase failed");
@@ -260,13 +243,10 @@ test("reports a generic failure when the runner wrote no outcome", async () => {
test("removes runtime credentials when posting fails", async () => { test("removes runtime credentials when posting fails", async () => {
const result = await fixture({ ok: true, body: "done" }); const result = await fixture({ ok: true, body: "done" });
await expect( await expect(() =>
postRuntime(result.manifestPath, context, async () => { postRuntime(result.manifestPath, context, () =>
const resolved = await Promise.resolve( Promise.resolve(new Response("failed", { status: 500 })),
new Response("failed", { status: 500 }), ),
);
return resolved;
}),
).rejects.toThrow("500"); ).rejects.toThrow("500");
assert(await missing(result.runtimeDir)); assert(await missing(result.runtimeDir));
}); });
@@ -275,11 +255,10 @@ test("preserves a Gitea transport failure without retrying a comment", async ()
const result = await fixture({ ok: true, body: "done" }); const result = await fixture({ ok: true, body: "done" });
let requests = 0; let requests = 0;
await expect( await expect(() =>
postRuntime(result.manifestPath, context, async () => { postRuntime(result.manifestPath, context, () => {
requests += 1; requests += 1;
await Promise.resolve(); return Promise.reject(new Error(`network failure ${requests}`));
throw new Error(`network failure ${requests}`);
}), }),
).rejects.toThrow("network failure 1"); ).rejects.toThrow("network failure 1");
@@ -287,33 +266,27 @@ test("preserves a Gitea transport failure without retrying a comment", async ()
assert(await missing(result.runtimeDir)); assert(await missing(result.runtimeDir));
}); });
test.skipIf(IS_WINDOWS)( test.skipIf(IS_WINDOWS)("refuses to follow an agent artifact symlink", async () => {
"refuses to follow an agent artifact symlink", const result = await fixture({ ok: true, body: "done" });
async () => { await symlink(result.reviewerFile, result.reviewPath);
const result = await fixture({ ok: true, body: "done" }); let requests = 0;
await symlink(result.reviewerFile, result.reviewPath);
let requests = 0;
await expect( await expect(() =>
postRuntime(result.manifestPath, context, async () => { postRuntime(result.manifestPath, context, () => {
requests += 1; requests += 1;
const resolved = await Promise.resolve( return Promise.resolve(new Response(null, { status: 200 }));
new Response(null, { status: 200 }), }),
); ).rejects.toThrow("regular private file");
return resolved;
}),
).rejects.toThrow("regular private file");
expect(requests).toBe(1); expect(requests).toBe(1);
assert(await missing(result.runtimeDir)); assert(await missing(result.runtimeDir));
}, });
);
test("reports an attributed failure when a pull request review is missing", async () => { test("reports an attributed failure when a pull request review is missing", async () => {
const result = await fixture({ ok: true, body: "done" }); const result = await fixture({ ok: true, body: "done" });
const bodies: unknown[] = []; const bodies: unknown[] = [];
await expect( await expect(() =>
postRuntime( postRuntime(
result.manifestPath, result.manifestPath,
{ {
+75 -149
View File
@@ -1,19 +1,10 @@
import type { Stats } from "node:fs"; import type { Stats } from "node:fs";
import { lstat, readFile, rm } from "node:fs/promises"; import { lstat, readFile, rm } from "node:fs/promises";
import nodePath from "node:path"; import { join } from "node:path";
import { field, isNotFound, isObject } from "#common"; import { isNotFound, isObject } from "#common";
import { import { failureFooter, type FailureReason, type ProfileFailure, withProfile } from "#profiles";
failureFooter, import { readRuntimeManifest, type RuntimeManifest, type RuntimeOutcome } from "#runtime";
type FailureReason,
type ProfileFailure,
withProfile,
} from "#profiles";
import {
readRuntimeManifest,
type RuntimeManifest,
type RuntimeOutcome,
} from "#runtime";
export interface PostContext { export interface PostContext {
apiUrl: string; apiUrl: string;
@@ -25,68 +16,45 @@ export interface PostContext {
interface Anchor { interface Anchor {
path: string; path: string;
line: number; line: number;
side: "NEW" | "OLD"; side: "new" | "old";
body: string; body: string;
} }
const ANSI = new RegExp(`${String.fromCodePoint(27)}\\[[0-9;]*[A-Za-z]`, "gu"); const ANSI = new RegExp(`${String.fromCodePoint(27)}\\[[0-9;]*[A-Za-z]`, "gu");
const stripAnsi = (text: string): string => text.replace(ANSI, ""); const stripAnsi = (text: string): string => text.replace(ANSI, "");
const VERDICTS = new Map<string, [event: string, mark: string]>([ const VERDICTS: NodeJS.Dict<[event: string, mark: string]> = {
["Approved", ["APPROVED", "✅"]], Approved: ["APPROVED", "✅"],
["Changes requested", ["REQUEST_CHANGES", "🛑"]], "Changes requested": ["REQUEST_CHANGES", "🛑"],
]); };
const PROFILE_TYPES = new Set<unknown>(["CLAUDE", "CODEX", "OPENCODE"]); const PROFILE_TYPES: Set<unknown> = new Set(["claude", "codex", "opencode"]);
const FAILURE_REASONS = new Set<unknown>([ const FAILURE_REASONS: Set<unknown> = new Set(["sign-in failed", "usage exhausted", "failed"]);
"SIGN_IN_FAILED", const isProfileType = (value: unknown): value is ProfileFailure["type"] => PROFILE_TYPES.has(value);
"USAGE_EXHAUSTED", const isFailureReason = (value: unknown): value is FailureReason => FAILURE_REASONS.has(value);
"FAILED",
]);
// Anchors written before the UPPER_SNAKE switch spell sides in lowercase.
const OLD_SIDES = new Map<unknown, Anchor["side"]>([
["new", "NEW"],
["old", "OLD"],
]);
const isProfileType = (value: unknown): value is ProfileFailure["type"] =>
PROFILE_TYPES.has(value);
const isFailureReason = (value: unknown): value is FailureReason =>
FAILURE_REASONS.has(value);
const failureComment = (failures: ProfileFailure[]): string => const failureComment = (failures: ProfileFailure[]): string =>
`AI bot failed.\n\n${failureFooter(failures)}`; `AI bot failed.\n\n${failureFooter(failures)}`;
// The `fetch` subset the reviewer posts through, which tests replace. // The `fetch` subset the reviewer posts through, which tests replace.
export type Fetcher = (url: string, init: RequestInit) => Promise<Response>; export type Fetcher = (url: string, init: RequestInit) => Promise<Response>;
class GiteaRequestError extends Error { class GiteaRequestError extends Error {}
constructor(message: string, options?: ErrorOptions) {
super(message, options);
this.name = "GiteaRequestError";
}
}
function parseAnchors(text: string, sourcePath: string): Anchor[] { function parseAnchors(text: string, sourcePath: string): Anchor[] {
const entries: unknown = JSON.parse(text); const entries: unknown = JSON.parse(text);
if (!Array.isArray(entries)) { if (!Array.isArray(entries)) throw new TypeError(`${sourcePath}: not an array`);
throw new TypeError(`${sourcePath}: not an array`);
}
return entries.map((entry: unknown, index) => { return entries.map((entry: unknown, index) => {
const at = `${sourcePath}[${index}]`; const at = `${sourcePath}[${index}]`;
if (!isObject(entry)) { if (!isObject(entry)) {
throw new TypeError(`${at}: not an object`); throw new TypeError(`${at}: not an object`);
} }
const path = field(entry, "path"); const { path, line, side = "new", body } = entry;
const line = field(entry, "line");
const givenSide = field(entry, "side");
const side =
givenSide === undefined ? "NEW" : (OLD_SIDES.get(givenSide) ?? givenSide);
const body = field(entry, "body");
if (typeof path !== "string" || path === "") { if (typeof path !== "string" || path === "") {
throw new TypeError(`${at}.path: expected a repository path`); throw new TypeError(`${at}.path: expected a repository path`);
} }
if (typeof line !== "number" || !Number.isInteger(line) || line < 1) { if (typeof line !== "number" || !Number.isInteger(line) || line < 1) {
throw new TypeError(`${at}.line: expected a line number`); throw new TypeError(`${at}.line: expected a line number`);
} }
if (side !== "NEW" && side !== "OLD") { if (side !== "new" && side !== "old") {
throw new Error(`${at}.side: expected "NEW" or "OLD"`); throw new Error(`${at}.side: expected "new" or "old"`);
} }
if (typeof body !== "string" || body.trim() === "") { if (typeof body !== "string" || body.trim() === "") {
throw new TypeError(`${at}.body: expected the finding`); throw new TypeError(`${at}.body: expected the finding`);
@@ -100,44 +68,43 @@ async function readOutcome(path: string): Promise<RuntimeOutcome> {
if (!isObject(value) || !("ok" in value)) { if (!isObject(value) || !("ok" in value)) {
throw new Error("invalid agent outcome"); throw new Error("invalid agent outcome");
} }
const ok = field(value, "ok"); const outcome = value;
if (ok === false) { if (outcome["ok"] === false) {
// Only known labels reach the comment, never raw agent output. // Only known labels reach the comment, never raw agent output.
const listed = field(value, "failures"); const failures: unknown[] = Array.isArray(outcome["failures"]) ? outcome["failures"] : [];
const failures: unknown[] = Array.isArray(listed) ? listed : [];
return { return {
ok: false, ok: false,
failures: failures.flatMap((entry: unknown) => { failures: failures.flatMap((entry: unknown) => {
const type = field(entry, "type"); const { type, model, reason } = isObject(entry) ? entry : {};
const model = field(entry, "model"); return isProfileType(type) && typeof model === "string" && isFailureReason(reason)
const reason = field(entry, "reason");
return isProfileType(type) &&
typeof model === "string" &&
isFailureReason(reason)
? [{ type, model, reason }] ? [{ type, model, reason }]
: []; : [];
}), }),
}; };
} }
const body = field(value, "body");
const reviewPath = field(value, "reviewPath");
const anchorsPath = field(value, "anchorsPath");
const profile = field(value, "profile");
if ( if (
ok !== true || outcome["ok"] !== true ||
typeof body !== "string" || typeof outcome["body"] !== "string" ||
typeof reviewPath !== "string" || typeof outcome["reviewPath"] !== "string" ||
typeof anchorsPath !== "string" || typeof outcome["anchorsPath"] !== "string" ||
!isObject(profile) !isObject(outcome["profile"])
) { ) {
throw new Error("invalid agent outcome"); throw new Error("invalid agent outcome");
} }
const type = field(profile, "type"); const profile = outcome["profile"];
const model = field(profile, "model"); if (!isProfileType(profile["type"]) || typeof profile["model"] !== "string") {
if (!isProfileType(type) || typeof model !== "string") {
throw new Error("invalid agent outcome"); throw new Error("invalid agent outcome");
} }
return { ok: true, body, reviewPath, anchorsPath, profile: { type, model } }; return {
ok: true,
body: outcome["body"],
reviewPath: outcome["reviewPath"],
anchorsPath: outcome["anchorsPath"],
profile: {
type: profile["type"],
model: profile["model"],
},
};
} }
async function readAgentArtifact( async function readAgentArtifact(
@@ -145,19 +112,13 @@ async function readAgentArtifact(
path: string, path: string,
name: string, name: string,
): Promise<string | null> { ): Promise<string | null> {
const profile = manifest.profiles.find( const profile = manifest.profiles.find((entry) => join(entry.home, name) === path);
(entry) => nodePath.join(entry.home, name) === path, if (profile === undefined) throw new Error(`${name}: outside profile home`);
); let stat: Stats;
if (profile === undefined) {
throw new Error(`${name}: outside profile home`);
}
let stat: Stats | null = null;
try { try {
stat = await lstat(path); stat = await lstat(path);
} catch (error) { } catch (error) {
if (isNotFound(error)) { if (isNotFound(error)) return null;
return null;
}
throw error; throw error;
} }
if ( if (
@@ -179,10 +140,9 @@ export async function postRuntime(
): Promise<void> { ): Promise<void> {
const manifest = await readRuntimeManifest(manifestPath); const manifest = await readRuntimeManifest(manifestPath);
try { try {
const reviewerText = await readFile(manifest.reviewerFile, "utf8"); const reviewerToken = (await readFile(manifest.reviewerFile, "utf8")).trim();
const reviewerToken = reviewerText.trim();
const request = async (path: string, body: unknown): Promise<void> => { const request = async (path: string, body: unknown): Promise<void> => {
let response: Response | null = null; let response: Response;
try { try {
response = await fetcher(`${context.apiUrl}/${path}`, { response = await fetcher(`${context.apiUrl}/${path}`, {
method: "POST", method: "POST",
@@ -197,21 +157,15 @@ export async function postRuntime(
throw new GiteaRequestError(`${path}: ${detail}`, { cause: error }); throw new GiteaRequestError(`${path}: ${detail}`, { cause: error });
} }
if (!response.ok) { if (!response.ok) {
throw new GiteaRequestError( throw new GiteaRequestError(`${path}: ${response.status} ${await response.text()}`);
`${path}: ${response.status} ${await response.text()}`,
);
} }
}; };
const postComment = async (body: string): Promise<void> => { const postComment = (body: string): Promise<void> =>
await request( request(`repos/${context.repository}/issues/${context.issueIndex}/comments`, {
`repos/${context.repository}/issues/${context.issueIndex}/comments`, body: stripAnsi(body),
{ });
body: stripAnsi(body),
},
);
};
let outcome: RuntimeOutcome | null = null; let outcome: RuntimeOutcome;
try { try {
outcome = await readOutcome(manifest.outcomeFile); outcome = await readOutcome(manifest.outcomeFile);
} catch (error) { } catch (error) {
@@ -224,11 +178,7 @@ export async function postRuntime(
} }
try { try {
const review = await readAgentArtifact( const review = await readAgentArtifact(manifest, outcome.reviewPath, "review.md");
manifest,
outcome.reviewPath,
"review.md",
);
if (review === null) { if (review === null) {
if (context.eventName === "pull_request") { if (context.eventName === "pull_request") {
throw new Error("agent did not write a pull request review"); throw new Error("agent did not write a pull request review");
@@ -238,61 +188,37 @@ export async function postRuntime(
} }
const [verdict = "", ...rest] = review.split("\n"); const [verdict = "", ...rest] = review.split("\n");
const [event, mark] = VERDICTS.get(verdict.trim()) ?? ["COMMENT", "💬"]; const [event, mark] = VERDICTS[verdict.trim()] ?? ["COMMENT", "💬"];
const anchorText = await readAgentArtifact( const anchorText = await readAgentArtifact(manifest, outcome.anchorsPath, "anchors.json");
manifest, const anchors = anchorText === null ? [] : parseAnchors(anchorText, outcome.anchorsPath);
outcome.anchorsPath, const postReview = (entries: Anchor[]): Promise<void> =>
"anchors.json", request(`repos/${context.repository}/pulls/${context.issueIndex}/reviews`, {
); body: stripAnsi(
const anchors = withProfile([`${mark} ${verdict.trim()}`, ...rest].join("\n"), outcome.profile),
anchorText === null ),
? [] event,
: parseAnchors(anchorText, outcome.anchorsPath); comments: entries.map(({ path, line, side, body }) => ({
const postReview = async (entries: Anchor[]): Promise<void> => { path,
await request( body: stripAnsi(withProfile(body, outcome.profile)),
`repos/${context.repository}/pulls/${context.issueIndex}/reviews`, new_position: side === "new" ? line : 0,
{ old_position: side === "old" ? line : 0,
body: stripAnsi( })),
withProfile( });
[`${mark} ${verdict.trim()}`, ...rest].join("\n"),
outcome.profile,
),
),
event,
comments: entries.map(({ path, line, side, body }) => ({
path,
body: stripAnsi(withProfile(body, outcome.profile)),
new_position: side === "NEW" ? line : 0,
old_position: side === "OLD" ? line : 0,
})),
},
);
};
await postReview(anchors).catch(async (error: unknown) => { await postReview(anchors).catch(async (error: unknown) => {
if (anchors.length === 0) { if (anchors.length === 0) throw error;
throw error;
}
console.error( console.error(
`inline comments rejected: ${error instanceof Error ? error.message : String(error)}`, `inline comments rejected: ${error instanceof Error ? error.message : String(error)}`,
); );
await postReview([]); await postReview([]);
}); });
} catch (error) { } catch (error) {
if (error instanceof GiteaRequestError) { if (error instanceof GiteaRequestError) throw error;
throw error; await postComment(failureComment([{ ...outcome.profile, reason: "failed" }]));
}
await postComment(
failureComment([{ ...outcome.profile, reason: "FAILED" }]),
);
throw error; throw error;
} }
} finally { } finally {
await rm(manifest.runtimeDir, { recursive: true }).catch( await rm(manifest.runtimeDir, { recursive: true }).catch((error: unknown) => {
(error: unknown) => { if (!isNotFound(error)) throw error;
if (!isNotFound(error)) { });
throw error;
}
},
);
} }
} }
+1 -3
View File
@@ -5,9 +5,7 @@ import { prepareRuntime } from "#runtime";
const env = (name: string): string => { const env = (name: string): string => {
const value = process.env[name]; const value = process.env[name];
if (value === undefined || value === "") { if (value === undefined || value === "") throw new Error(`${name} is not set`);
throw new Error(`${name} is not set`);
}
return value; return value;
}; };
+3 -9
View File
@@ -6,12 +6,8 @@ import { isNotFound } from "#common";
import { exitCode } from "./child.ts"; import { exitCode } from "./child.ts";
test("reports the exit code", async () => { test("reports the exit code", async () => {
expect( expect(await exitCode(spawn("/bin/sh", ["-c", "exit 0"], { stdio: "ignore" }))).toBe(0);
await exitCode(spawn("/bin/sh", ["-c", "exit 0"], { stdio: "ignore" })), expect(await exitCode(spawn("/bin/sh", ["-c", "exit 3"], { stdio: "ignore" }))).toBe(3);
).toBe(0);
expect(
await exitCode(spawn("/bin/sh", ["-c", "exit 3"], { stdio: "ignore" })),
).toBe(3);
}); });
test("reports a signal as 128 plus its number", async () => { test("reports a signal as 128 plus its number", async () => {
@@ -20,9 +16,7 @@ test("reports a signal as 128 plus its number", async () => {
}); });
test("resolves on exit while a grandchild still holds the output open", async () => { test("resolves on exit while a grandchild still holds the output open", async () => {
const child = spawn("/bin/sh", ["-c", "sleep 2 & exit 5"], { const child = spawn("/bin/sh", ["-c", "sleep 2 & exit 5"], { stdio: ["ignore", "pipe", "pipe"] });
stdio: ["ignore", "pipe", "pipe"],
});
const started = Date.now(); const started = Date.now();
expect(await exitCode(child)).toBe(5); expect(await exitCode(child)).toBe(5);
expect(Date.now() - started).toBeLessThan(1500); expect(Date.now() - started).toBeLessThan(1500);
+1 -4
View File
@@ -23,10 +23,7 @@ export function exitCode(child: ChildProcess): Promise<number> {
} }
// Writes a chunk, waiting for the stream to drain when its buffer is full. // Writes a chunk, waiting for the stream to drain when its buffer is full.
export async function echo( export async function echo(stream: Writable, chunk: string | Uint8Array): Promise<void> {
stream: Writable,
chunk: string | Uint8Array,
): Promise<void> {
if (!stream.write(chunk)) { if (!stream.write(chunk)) {
await once(stream, "drain"); await once(stream, "drain");
} }
+70 -106
View File
@@ -1,13 +1,5 @@
import { spawnSync, type SpawnSyncReturns } from "node:child_process"; import { spawnSync, type SpawnSyncReturns } from "node:child_process";
import { import { chmod, chown, mkdir, readFile, rm, symlink, writeFile } from "node:fs/promises";
chmod,
chown,
mkdir,
readFile,
rm,
symlink,
writeFile,
} from "node:fs/promises";
import process from "node:process"; import process from "node:process";
import { expect, test } from "vite-plus/test"; import { expect, test } from "vite-plus/test";
@@ -15,15 +7,11 @@ import { isNotFound } from "#common";
import type { RuntimeProfile } from "#runtime"; import type { RuntimeProfile } from "#runtime";
import { currentUid, IS_ROOT, IS_WINDOWS, makeTempDir } from "#testing"; import { currentUid, IS_ROOT, IS_WINDOWS, makeTempDir } from "#testing";
import { import { isRunnableProfileProcess, killProfileProcesses, readProfileFile } from "./isolation.ts";
isRunnableProfileProcess,
killProfileProcesses,
readProfileFile,
} from "./isolation.ts";
const profile = (uid: number, home: string): RuntimeProfile => ({ const profile = (uid: number, home: string): RuntimeProfile => ({
index: uid - 20_000, index: uid - 20_000,
type: "CLAUDE", type: "claude",
model: "test", model: "test",
uid, uid,
gid: uid, gid: uid,
@@ -37,14 +25,14 @@ function runAs(
selected: RuntimeProfile, selected: RuntimeProfile,
command: string, command: string,
args: string[], args: string[],
env?: ReadonlyMap<string, string>, env?: NodeJS.ProcessEnv,
): SpawnSyncReturns<string> { ): SpawnSyncReturns<string> {
return spawnSync(command, args, { return spawnSync(command, args, {
cwd: "/", cwd: "/",
uid: selected.uid, uid: selected.uid,
gid: selected.gid, gid: selected.gid,
encoding: "utf8", encoding: "utf8",
...(env !== undefined && { env: Object.fromEntries(env) }), ...(env !== undefined && { env }),
}); });
} }
@@ -53,96 +41,72 @@ test("zombie process entries are already quiescent", () => {
expect(isRunnableProfileProcess(status, 20_010)).toBe(false); expect(isRunnableProfileProcess(status, 20_010)).toBe(false);
}); });
test.skipIf(IS_WINDOWS)( test.skipIf(IS_WINDOWS)("refuses to read a profile result symlink as root", async () => {
"refuses to read a profile result symlink as root", const root = await makeTempDir();
async () => { try {
const root = await makeTempDir(); const secret = `${root}/reviewer-token`;
try { const result = `${root}/result.md`;
const secret = `${root}/reviewer-token`; await writeFile(secret, "reviewer-secret", { mode: 0o600 });
const result = `${root}/result.md`; await symlink(secret, result);
await writeFile(secret, "reviewer-secret", { mode: 0o600 });
await symlink(secret, result);
await expect( await expect(() => readProfileFile(profile(currentUid(), root), result)).rejects.toThrow(
readProfileFile(profile(currentUid(), root), result), "regular private file",
).rejects.toThrow("regular private file");
} finally {
await rm(root, { recursive: true });
}
},
);
test.skipIf(!IS_ROOT)(
"a profile process can read only its own private files",
async () => {
const root = await makeTempDir();
await chmod(root, 0o711);
try {
const homeA = `${root}/a`;
const homeB = `${root}/b`;
await mkdir(homeA, { mode: 0o700 });
await mkdir(homeB, { mode: 0o700 });
await chown(homeA, 20_000, 20_000);
await chown(homeB, 20_001, 20_001);
await writeFile(`${homeA}/token`, "own", { mode: 0o600 });
await chown(`${homeA}/token`, 20_000, 20_000);
await writeFile(`${homeB}/token`, "sibling", { mode: 0o600 });
await chown(`${homeB}/token`, 20_001, 20_001);
await writeFile(`${root}/reviewer`, "root", { mode: 0o600 });
const selected = profile(20_000, homeA);
const own = runAs(selected, "/bin/cat", [`${homeA}/token`]);
const sibling = runAs(selected, "/bin/cat", [`${homeB}/token`]);
const reviewer = runAs(selected, "/bin/cat", [`${root}/reviewer`]);
expect(own.stdout).toBe("own");
expect(own.status).toBe(0);
expect(sibling.status).not.toBe(0);
expect(reviewer.status).not.toBe(0);
} finally {
await rm(root, { recursive: true });
}
},
);
test.skipIf(!IS_ROOT)(
"cleanup leaves no runnable daemonized process",
async () => {
const selected = profile(20_010, "/tmp");
const launched = runAs(selected, "/bin/sh", [
"-c",
"sleep 60 >/dev/null 2>&1 & echo $!",
]);
const pid = Number(launched.stdout.trim());
expect(Number.isInteger(pid)).toBe(true);
await killProfileProcesses(selected.uid);
const status = await readFile(`/proc/${pid}/status`, "utf8").catch(
(error: unknown) => {
if (isNotFound(error)) {
return null;
}
throw error;
},
); );
expect( } finally {
status === null || !isRunnableProfileProcess(status, selected.uid), await rm(root, { recursive: true });
).toBe(true); }
}, });
);
test.skipIf(!IS_ROOT)( test.skipIf(!IS_ROOT)("a profile process can read only its own private files", async () => {
"the agent process cannot read its coordinator environment", const root = await makeTempDir();
() => { await chmod(root, 0o711);
const selected = profile(20_020, "/tmp"); try {
const result = runAs( const homeA = `${root}/a`;
selected, const homeB = `${root}/b`;
"/usr/bin/cat", await mkdir(homeA, { mode: 0o700 });
[`/proc/${process.pid}/environ`], await mkdir(homeB, { mode: 0o700 });
new Map([["PARENT_SECRET", "must-not-cross-boundary"]]), await chown(homeA, 20_000, 20_000);
); await chown(homeB, 20_001, 20_001);
await writeFile(`${homeA}/token`, "own", { mode: 0o600 });
await chown(`${homeA}/token`, 20_000, 20_000);
await writeFile(`${homeB}/token`, "sibling", { mode: 0o600 });
await chown(`${homeB}/token`, 20_001, 20_001);
await writeFile(`${root}/reviewer`, "root", { mode: 0o600 });
expect(result.status).not.toBe(0); const selected = profile(20_000, homeA);
}, const own = runAs(selected, "/bin/cat", [`${homeA}/token`]);
); const sibling = runAs(selected, "/bin/cat", [`${homeB}/token`]);
const reviewer = runAs(selected, "/bin/cat", [`${root}/reviewer`]);
expect(own.stdout).toBe("own");
expect(own.status).toBe(0);
expect(sibling.status).not.toBe(0);
expect(reviewer.status).not.toBe(0);
} finally {
await rm(root, { recursive: true });
}
});
test.skipIf(!IS_ROOT)("cleanup leaves no runnable daemonized process", async () => {
const selected = profile(20_010, "/tmp");
const launched = runAs(selected, "/bin/sh", ["-c", "sleep 60 >/dev/null 2>&1 & echo $!"]);
const pid = Number(launched.stdout.trim());
expect(Number.isInteger(pid)).toBe(true);
await killProfileProcesses(selected.uid);
const status = await readFile(`/proc/${pid}/status`, "utf8").catch((error: unknown) => {
if (isNotFound(error)) return null;
throw error;
});
expect(status === null || !isRunnableProfileProcess(status, selected.uid)).toBe(true);
});
test.skipIf(!IS_ROOT)("the agent process cannot read its coordinator environment", () => {
const selected = profile(20_020, "/tmp");
const result = runAs(selected, "/usr/bin/cat", [`/proc/${process.pid}/environ`], {
PARENT_SECRET: "must-not-cross-boundary",
});
expect(result.status).not.toBe(0);
});
+8 -27
View File
@@ -6,8 +6,8 @@ import { isNotFound } from "#common";
import type { RuntimeProfile } from "#runtime"; import type { RuntimeProfile } from "#runtime";
export function isRunnableProfileProcess(status: string, uid: number): boolean { export function isRunnableProfileProcess(status: string, uid: number): boolean {
const owner = /^Uid:\s+(?<uid>\d+)/mu.exec(status)?.groups?.["uid"]; const owner = /^Uid:\s+(\d+)/mu.exec(status)?.[1];
const state = /^State:\s+(?<state>\w)/mu.exec(status)?.groups?.["state"]; const state = /^State:\s+(\w)/mu.exec(status)?.[1];
return owner !== undefined && Number(owner) === uid && state !== "Z"; return owner !== undefined && Number(owner) === uid && state !== "Z";
} }
@@ -17,54 +17,35 @@ async function profileProcessIds(uid: number): Promise<number[]> {
.filter((entry) => entry.isDirectory() && /^\d+$/u.test(entry.name)) .filter((entry) => entry.isDirectory() && /^\d+$/u.test(entry.name))
.map((entry) => entry.name); .map((entry) => entry.name);
const statuses = await Promise.all( const statuses = await Promise.all(
pids.map(async (pid) => { pids.map((pid) => readFile(`/proc/${pid}/status`, "utf8").catch(() => null)),
const status = await readFile(`/proc/${pid}/status`, "utf8").catch(
() => null,
);
return status;
}),
); );
return pids return pids
.filter((_pid, index) => { .filter((_pid, index) => {
const status = statuses[index]; const status = statuses[index];
return ( return status !== null && status !== undefined && isRunnableProfileProcess(status, uid);
status !== null &&
status !== undefined &&
isRunnableProfileProcess(status, uid)
);
}) })
.map(Number); .map(Number);
} }
// Kills the UID's processes every 10 ms until none is left, for up to 100 rounds. // Kills the UID's processes every 10 ms until none is left, for up to 100 rounds.
export async function killProfileProcesses( export async function killProfileProcesses(uid: number, attempt = 0): Promise<void> {
uid: number,
attempt = 0,
): Promise<void> {
if (attempt === 100) { if (attempt === 100) {
throw new Error(`profile UID ${uid} still owns processes after cleanup`); throw new Error(`profile UID ${uid} still owns processes after cleanup`);
} }
const ids = await profileProcessIds(uid); const ids = await profileProcessIds(uid);
if (ids.length === 0) { if (ids.length === 0) return;
return;
}
for (const pid of ids) { for (const pid of ids) {
try { try {
process.kill(pid, "SIGKILL"); process.kill(pid, "SIGKILL");
} catch (error) { } catch (error) {
if (!isNotFound(error)) { if (!isNotFound(error)) throw error;
throw error;
}
} }
} }
await sleep(10); await sleep(10);
await killProfileProcesses(uid, attempt + 1); await killProfileProcesses(uid, attempt + 1);
} }
export async function readProfileFile( export async function readProfileFile(profile: RuntimeProfile, path: string): Promise<string> {
profile: RuntimeProfile,
path: string,
): Promise<string> {
const stat = await lstat(path); const stat = await lstat(path);
if ( if (
!stat.isFile() || !stat.isFile() ||
+1 -6
View File
@@ -9,9 +9,4 @@ export {
sanitizedEnvironment, sanitizedEnvironment,
withProfile, withProfile,
} from "./profiles.ts"; } from "./profiles.ts";
export type { export type { BotProfile, FailureReason, ProfileFailure, ProfileIdentity } from "./profiles.ts";
BotProfile,
FailureReason,
ProfileFailure,
ProfileIdentity,
} from "./profiles.ts";
+83 -109
View File
@@ -11,44 +11,42 @@ import {
} from "./profiles.ts"; } from "./profiles.ts";
test("formats profile attribution as a Markdown quote", () => { test("formats profile attribution as a Markdown quote", () => {
expect( expect(profileFooter({ type: "opencode", model: "openrouter/qwen/qwen3.8-27b" })).toBe(
profileFooter({ type: "OPENCODE", model: "openrouter/qwen/qwen3.8-27b" }), "> Profile: `opencode` · `openrouter/qwen/qwen3.8-27b`",
).toBe("> Profile: `opencode` · `openrouter/qwen/qwen3.8-27b`"); );
}); });
test("falls through only after usage exhaustion", async () => { test("falls through only after usage exhaustion", async () => {
const visited: string[] = []; const visited: string[] = [];
const result = await runProfiles( const result = await runProfiles(
[ [
{ type: "CLAUDE", model: "claude-sonnet-5", token: "first" }, { type: "claude", model: "claude-sonnet-5", token: "first" },
{ type: "CODEX", model: "gpt-5.6-terra" }, { type: "codex", model: "gpt-5.6-terra" },
], ],
async (profile) => { (profile) => {
visited.push(profile.type); visited.push(profile.type);
if (profile.type === "CLAUDE") { if (profile.type === "claude") {
throw new Error("You've hit your usage limit"); throw new Error("You've hit your usage limit");
} }
const resolved = await Promise.resolve("done"); return Promise.resolve("done");
return resolved;
}, },
); );
expect(result).toBe("done"); expect(result).toBe("done");
expect(visited).toStrictEqual(["CLAUDE", "CODEX"]); expect(visited).toStrictEqual(["claude", "codex"]);
}); });
test("recognizes Claude's weekly limit message", async () => { test("recognizes Claude's weekly limit message", async () => {
const result = await runProfiles( const result = await runProfiles(
[ [
{ type: "CLAUDE", model: "claude-sonnet-5", token: "first" }, { type: "claude", model: "claude-sonnet-5", token: "first" },
{ type: "CODEX", model: "gpt-5.6-terra" }, { type: "codex", model: "gpt-5.6-terra" },
], ],
async (profile) => { (profile) => {
if (profile.type === "CLAUDE") { if (profile.type === "claude") {
throw new Error("You've hit your weekly limit · resets 12am (UTC)"); throw new Error("You've hit your weekly limit · resets 12am (UTC)");
} }
const resolved = await Promise.resolve("fallback"); return Promise.resolve("fallback");
return resolved;
}, },
); );
@@ -57,23 +55,17 @@ test("recognizes Claude's weekly limit message", async () => {
test("recognizes provider API exhaustion status", async () => { test("recognizes provider API exhaustion status", async () => {
const results = await Promise.all( const results = await Promise.all(
["API Error: 402 Insufficient funds", "HTTP error: 429"].map( ["API Error: 402 Insufficient funds", "HTTP error: 429"].map((message) =>
async (message) => { runProfiles(
const result = await runProfiles( [
[ { type: "claude", model: "claude-sonnet-5", token: "first" },
{ type: "CLAUDE", model: "claude-sonnet-5", token: "first" }, { type: "codex", model: "gpt-5.6-terra" },
{ type: "CODEX", model: "gpt-5.6-terra" }, ],
], (profile) => {
async (profile) => { if (profile.type === "claude") throw new Error(message);
if (profile.type === "CLAUDE") { return Promise.resolve("fallback");
throw new Error(message); },
} ),
const resolved = await Promise.resolve("fallback");
return resolved;
},
);
return result;
},
), ),
); );
@@ -84,27 +76,24 @@ test("falls through after a sign-in failure and records each try", async () => {
const failures: ProfileFailure[] = []; const failures: ProfileFailure[] = [];
const result = await runProfiles( const result = await runProfiles(
[ [
{ type: "CODEX", model: "gpt-5.6-terra" }, { type: "codex", model: "gpt-5.6-terra" },
{ type: "CLAUDE", model: "claude-sonnet-5", token: "first" }, { type: "claude", model: "claude-sonnet-5", token: "first" },
{ type: "OPENCODE", model: "openrouter/qwen/qwen3.8-27b" }, { type: "opencode", model: "openrouter/qwen/qwen3.8-27b" },
], ],
async (profile) => { (profile) => {
if (profile.type === "CODEX") { if (profile.type === "codex") {
throw new AgentAuthError("codex sign-in failed"); throw new AgentAuthError("codex sign-in failed");
} }
if (profile.type === "CLAUDE") { if (profile.type === "claude") throw new Error("API Error: 429");
throw new Error("API Error: 429"); return Promise.resolve("fallback");
}
const resolved = await Promise.resolve("fallback");
return resolved;
}, },
failures, failures,
); );
expect(result).toBe("fallback"); expect(result).toBe("fallback");
expect(failures).toStrictEqual([ expect(failures).toStrictEqual([
{ type: "CODEX", model: "gpt-5.6-terra", reason: "SIGN_IN_FAILED" }, { type: "codex", model: "gpt-5.6-terra", reason: "sign-in failed" },
{ type: "CLAUDE", model: "claude-sonnet-5", reason: "USAGE_EXHAUSTED" }, { type: "claude", model: "claude-sonnet-5", reason: "usage exhausted" },
]); ]);
expect(failureFooter(failures)).toStrictEqual( expect(failureFooter(failures)).toStrictEqual(
"> Tried: `codex` · `gpt-5.6-terra` (sign-in failed), " + "> Tried: `codex` · `gpt-5.6-terra` (sign-in failed), " +
@@ -114,11 +103,11 @@ test("falls through after a sign-in failure and records each try", async () => {
test("throws the last sign-in failure when every profile fails", async () => { test("throws the last sign-in failure when every profile fails", async () => {
const failures: ProfileFailure[] = []; const failures: ProfileFailure[] = [];
await expect( await expect(() =>
runProfiles( runProfiles(
[ [
{ type: "CODEX", model: "gpt-5.6-terra" }, { type: "codex", model: "gpt-5.6-terra" },
{ type: "CLAUDE", model: "claude-sonnet-5", token: "first" }, { type: "claude", model: "claude-sonnet-5", token: "first" },
], ],
(profile) => { (profile) => {
throw new AgentAuthError(`${profile.type} sign-in failed`); throw new AgentAuthError(`${profile.type} sign-in failed`);
@@ -127,24 +116,19 @@ test("throws the last sign-in failure when every profile fails", async () => {
), ),
).rejects.toThrow( ).rejects.toThrow(
expect.toSatisfy( expect.toSatisfy(
(error: unknown) => (e: unknown) => e instanceof AgentAuthError && e.message.includes("claude sign-in failed"),
error instanceof AgentAuthError &&
error.message.includes("CLAUDE sign-in failed"),
), ),
); );
expect(failures.map(({ reason }) => reason)).toStrictEqual([ expect(failures.map(({ reason }) => reason)).toStrictEqual(["sign-in failed", "sign-in failed"]);
"SIGN_IN_FAILED",
"SIGN_IN_FAILED",
]);
}); });
test("preserves an ordinary agent failure", async () => { test("preserves an ordinary agent failure", async () => {
const visited: string[] = []; const visited: string[] = [];
await expect( await expect(() =>
runProfiles( runProfiles(
[ [
{ type: "CLAUDE", model: "claude-sonnet-5", token: "first" }, { type: "claude", model: "claude-sonnet-5", token: "first" },
{ type: "CODEX", model: "gpt-5.6-terra" }, { type: "codex", model: "gpt-5.6-terra" },
], ],
(profile) => { (profile) => {
visited.push(profile.type); visited.push(profile.type);
@@ -152,16 +136,16 @@ test("preserves an ordinary agent failure", async () => {
}, },
), ),
).rejects.toThrow("tests failed"); ).rejects.toThrow("tests failed");
expect(visited).toStrictEqual(["CLAUDE"]); expect(visited).toStrictEqual(["claude"]);
}); });
test("does not mistake incidental quota text for exhaustion", async () => { test("does not mistake incidental quota text for exhaustion", async () => {
const visited: string[] = []; const visited: string[] = [];
await expect( await expect(() =>
runProfiles( runProfiles(
[ [
{ type: "CLAUDE", model: "claude-sonnet-5", token: "first" }, { type: "claude", model: "claude-sonnet-5", token: "first" },
{ type: "CODEX", model: "gpt-5.6-terra" }, { type: "codex", model: "gpt-5.6-terra" },
], ],
(profile) => { (profile) => {
visited.push(profile.type); visited.push(profile.type);
@@ -169,27 +153,27 @@ test("does not mistake incidental quota text for exhaustion", async () => {
}, },
), ),
).rejects.toThrow("quota parser test failed"); ).rejects.toThrow("quota parser test failed");
expect(visited).toStrictEqual(["CLAUDE"]); expect(visited).toStrictEqual(["claude"]);
}); });
test("exposes only the selected profile credential to the agent", () => { test("exposes only the selected profile credential to the agent", () => {
const base = new Map([ const base = {
["PATH", "/usr/bin"], PATH: "/usr/bin",
["HOME", "/home/bot"], HOME: "/home/bot",
["UNRELATED_SECRET", "must-not-reach-agent"], UNRELATED_SECRET: "must-not-reach-agent",
["BOT_AGENTS_MASTER_KEY", "master"], BOT_AGENTS_MASTER_KEY: "master",
["PROFILES", "contains every secret"], PROFILES: "contains every secret",
["REVIEWER_TOKEN", "reviewer"], REVIEWER_TOKEN: "reviewer",
["CLAUDE_CODE_OAUTH_TOKEN", "old-claude"], CLAUDE_CODE_OAUTH_TOKEN: "old-claude",
["ANTHROPIC_API_KEY", "old-anthropic-key"], ANTHROPIC_API_KEY: "old-anthropic-key",
["ANTHROPIC_AUTH_TOKEN", "old-anthropic-token"], ANTHROPIC_AUTH_TOKEN: "old-anthropic-token",
["OPENAI_API_KEY", "old-openai"], OPENAI_API_KEY: "old-openai",
["CODEX_API_KEY", "old-codex-key"], CODEX_API_KEY: "old-codex-key",
["CODEX_ACCESS_TOKEN", "old-codex-token"], CODEX_ACCESS_TOKEN: "old-codex-token",
]); };
const profile = { const profile = {
index: 0, index: 0,
type: "CLAUDE" as const, type: "claude" as const,
model: "claude-sonnet-5", model: "claude-sonnet-5",
uid: 20_000, uid: 20_000,
gid: 20_000, gid: 20_000,
@@ -197,25 +181,21 @@ test("exposes only the selected profile credential to the agent", () => {
tokenFile: "/runtime/profile-0/token", tokenFile: "/runtime/profile-0/token",
}; };
expect(agentEnvironment(base, profile, "selected")).toStrictEqual( expect(agentEnvironment(base, profile, "selected")).toStrictEqual({
new Map([ PATH: "/usr/bin",
["PATH", "/usr/bin"], HOME: "/runtime/profile-0",
["HOME", "/runtime/profile-0"], CLAUDE_CODE_OAUTH_TOKEN: "selected",
["CLAUDE_CODE_OAUTH_TOKEN", "selected"], });
]), expect(sanitizedEnvironment(base)).toStrictEqual({
); PATH: "/usr/bin",
expect(sanitizedEnvironment(base)).toStrictEqual( HOME: "/home/bot",
new Map([ });
["PATH", "/usr/bin"],
["HOME", "/home/bot"],
]),
);
}); });
test("uses a private Codex home without inventing an API credential", () => { test("uses a private Codex home without inventing an API credential", () => {
const profile = { const profile = {
index: 1, index: 1,
type: "CODEX" as const, type: "codex" as const,
model: "gpt-5.6-terra", model: "gpt-5.6-terra",
uid: 20_001, uid: 20_001,
gid: 20_001, gid: 20_001,
@@ -223,19 +203,17 @@ test("uses a private Codex home without inventing an API credential", () => {
tokenFile: null, tokenFile: null,
}; };
expect(agentEnvironment(new Map([["PATH", "/bin"]]), profile)).toStrictEqual( expect(agentEnvironment({ PATH: "/bin" }, profile)).toStrictEqual({
new Map([ PATH: "/bin",
["PATH", "/bin"], HOME: "/runtime/profile-1",
["HOME", "/runtime/profile-1"], CODEX_HOME: "/runtime/profile-1/.codex",
["CODEX_HOME", "/runtime/profile-1/.codex"], });
]),
);
}); });
test("exposes an OpenRouter key only to the OpenCode profile", () => { test("exposes an OpenRouter key only to the OpenCode profile", () => {
const profile = { const profile = {
index: 2, index: 2,
type: "OPENCODE" as const, type: "opencode" as const,
model: "openrouter/qwen/qwen3.8-27b", model: "openrouter/qwen/qwen3.8-27b",
uid: 20_002, uid: 20_002,
gid: 20_002, gid: 20_002,
@@ -243,13 +221,9 @@ test("exposes an OpenRouter key only to the OpenCode profile", () => {
tokenFile: "/runtime/profile-2/token", tokenFile: "/runtime/profile-2/token",
}; };
expect( expect(agentEnvironment({ PATH: "/bin" }, profile, "selected")).toStrictEqual({
agentEnvironment(new Map([["PATH", "/bin"]]), profile, "selected"), PATH: "/bin",
).toStrictEqual( HOME: "/runtime/profile-2",
new Map([ OPENROUTER_API_KEY: "selected",
["PATH", "/bin"], });
["HOME", "/runtime/profile-2"],
["OPENROUTER_API_KEY", "selected"],
]),
);
}); });
+47 -92
View File
@@ -1,6 +1,6 @@
// The agent and model a profile runs, which every report names. // The agent and model a profile runs, which every report names.
export interface ProfileIdentity { export interface ProfileIdentity {
type: "CLAUDE" | "CODEX" | "OPENCODE"; type: "claude" | "codex" | "opencode";
model: string; model: string;
} }
@@ -8,39 +8,15 @@ export interface BotProfile extends ProfileIdentity {
token?: string; token?: string;
} }
// The lowercase name a profile type reads as in posted comments.
function profileName(type: ProfileIdentity["type"]): string {
switch (type) {
case "CLAUDE":
return "claude";
case "CODEX":
return "codex";
case "OPENCODE":
return "opencode";
}
}
export function profileFooter(profile: ProfileIdentity): string { export function profileFooter(profile: ProfileIdentity): string {
return `> Profile: \`${profileName(profile.type)}\` · \`${profile.model}\``; return `> Profile: \`${profile.type}\` · \`${profile.model}\``;
} }
export function withProfile(body: string, profile: ProfileIdentity): string { export function withProfile(body: string, profile: ProfileIdentity): string {
return `${body}\n\n${profileFooter(profile)}`; return `${body}\n\n${profileFooter(profile)}`;
} }
export type FailureReason = "SIGN_IN_FAILED" | "USAGE_EXHAUSTED" | "FAILED"; export type FailureReason = "sign-in failed" | "usage exhausted" | "failed";
// The words a failure reason reads as in logs and posted comments.
function toMessage(reason: FailureReason): string {
switch (reason) {
case "SIGN_IN_FAILED":
return "sign-in failed";
case "USAGE_EXHAUSTED":
return "usage exhausted";
case "FAILED":
return "failed";
}
}
export interface ProfileFailure extends ProfileIdentity { export interface ProfileFailure extends ProfileIdentity {
reason: FailureReason; reason: FailureReason;
@@ -53,12 +29,7 @@ interface ProfileHome {
} }
// Raised once an agent's credentials are rejected and any re-login is spent. // Raised once an agent's credentials are rejected and any re-login is spent.
export class AgentAuthError extends Error { export class AgentAuthError extends Error {}
constructor(message: string, options?: ErrorOptions) {
super(message, options);
this.name = "AgentAuthError";
}
}
function isUsageExhausted(error: unknown): boolean { function isUsageExhausted(error: unknown): boolean {
return /(?:usage|rate) limit|hit your (?:weekly )?limit|insufficient_quota|exceeded your current quota|too many requests|(?:api error|http error|http|status(?: code)?)[ :]+4(?:02|29)\b/iu.test( return /(?:usage|rate) limit|hit your (?:weekly )?limit|insufficient_quota|exceeded your current quota|too many requests|(?:api error|http error|http|status(?: code)?)[ :]+4(?:02|29)\b/iu.test(
@@ -67,54 +38,50 @@ function isUsageExhausted(error: unknown): boolean {
} }
function failureReason(error: unknown): FailureReason { function failureReason(error: unknown): FailureReason {
if (error instanceof AgentAuthError) { if (error instanceof AgentAuthError) return "sign-in failed";
return "SIGN_IN_FAILED"; return isUsageExhausted(error) ? "usage exhausted" : "failed";
}
return isUsageExhausted(error) ? "USAGE_EXHAUSTED" : "FAILED";
} }
export function failureFooter(failures: ProfileFailure[]): string { export function failureFooter(failures: ProfileFailure[]): string {
if (failures.length === 0) { if (failures.length === 0) return "> Profile: none";
return "> Profile: none";
}
return `> Tried: ${failures return `> Tried: ${failures
.map( .map(({ type, model, reason }) => `\`${type}\` · \`${model}\` (${reason})`)
({ type, model, reason }) =>
`\`${profileName(type)}\` · \`${model}\` (${toMessage(reason)})`,
)
.join(", ")}`; .join(", ")}`;
} }
// Tries the profiles in order, moving on only after a sign-in failure or // Tries the profiles from `index` on, moving on only after a sign-in failure
// exhausted usage, and records every profile it tried. // or exhausted usage, and records every profile it tried.
export async function runProfiles<T, P extends ProfileIdentity>( async function attemptFrom<T, P extends ProfileIdentity>(
profiles: P[],
attempt: (profile: P) => Promise<T>,
failures: ProfileFailure[],
index: number,
): Promise<T> {
const profile = profiles[index];
if (profile === undefined) {
throw new Error("profiles must contain at least one profile");
}
try {
return await attempt(profile);
} catch (error) {
const reason = failureReason(error);
failures.push({ type: profile.type, model: profile.model, reason });
if (reason === "failed" || index === profiles.length - 1) throw error;
console.error(`${profile.type} ${reason}; trying next profile`);
return attemptFrom(profiles, attempt, failures, index + 1);
}
}
export function runProfiles<T, P extends ProfileIdentity>(
profiles: P[], profiles: P[],
attempt: (profile: P) => Promise<T>, attempt: (profile: P) => Promise<T>,
failures: ProfileFailure[] = [], failures: ProfileFailure[] = [],
): Promise<T> { ): Promise<T> {
for (const [index, profile] of profiles.entries()) { return attemptFrom(profiles, attempt, failures, 0);
try {
return await attempt(profile);
} catch (error) {
const reason = failureReason(error);
failures.push({ type: profile.type, model: profile.model, reason });
if (reason === "FAILED" || index === profiles.length - 1) {
throw error;
}
console.error(
`${profile.type} ${toMessage(reason)}; trying next profile`,
);
}
}
throw new Error("profiles must contain at least one profile");
} }
// Environments are maps from variable name to value, converted to the object export function sanitizedEnvironment(environment: NodeJS.ProcessEnv): NodeJS.ProcessEnv {
// form only where a child process is spawned. const result: NodeJS.ProcessEnv = {};
export function sanitizedEnvironment(
environment: ReadonlyMap<string, string>,
): Map<string, string> {
const result = new Map<string, string>();
for (const name of [ for (const name of [
"PATH", "PATH",
"HOME", "HOME",
@@ -141,39 +108,27 @@ export function sanitizedEnvironment(
"SSL_CERT_DIR", "SSL_CERT_DIR",
"NODE_EXTRA_CA_CERTS", "NODE_EXTRA_CA_CERTS",
]) { ]) {
const value = environment.get(name); const value = environment[name];
if (value !== undefined) { if (value !== undefined) result[name] = value;
result.set(name, value);
}
} }
return result; return result;
} }
// The environment variable each agent CLI reads its credential from.
function tokenVariable(type: ProfileIdentity["type"]): string {
switch (type) {
case "CLAUDE":
return "CLAUDE_CODE_OAUTH_TOKEN";
case "CODEX":
return "OPENAI_API_KEY";
case "OPENCODE":
return "OPENROUTER_API_KEY";
}
}
export function agentEnvironment( export function agentEnvironment(
environment: ReadonlyMap<string, string>, environment: NodeJS.ProcessEnv,
profile: ProfileHome, profile: ProfileHome,
token?: string, token?: string,
): Map<string, string> { ): NodeJS.ProcessEnv {
const result = sanitizedEnvironment(environment); const result = sanitizedEnvironment(environment);
result.set("HOME", profile.home); result["HOME"] = profile.home;
if (profile.type === "CODEX") { if (profile.type === "codex") result["CODEX_HOME"] = `${profile.home}/.codex`;
result.set("CODEX_HOME", `${profile.home}/.codex`);
}
if (token !== undefined && token !== "") { if (token !== undefined && token !== "") {
const tokenName = tokenVariable(profile.type); const tokenName = {
result.set(tokenName, token); claude: "CLAUDE_CODE_OAUTH_TOKEN",
codex: "OPENAI_API_KEY",
opencode: "OPENROUTER_API_KEY",
}[profile.type];
result[tokenName] = token;
} }
return result; return result;
} }
+86 -173
View File
@@ -24,13 +24,8 @@ import {
retryInvalidToken, retryInvalidToken,
stageCodexAuth, stageCodexAuth,
} from "#agents"; } from "#agents";
import { field, isObject } from "#common"; import { isObject } from "#common";
import { import { echo, exitCode, killProfileProcesses, readProfileFile } from "#processes";
echo,
exitCode,
killProfileProcesses,
readProfileFile,
} from "#processes";
import { import {
AgentAuthError, AgentAuthError,
agentEnvironment, agentEnvironment,
@@ -40,11 +35,7 @@ import {
sanitizedEnvironment, sanitizedEnvironment,
withProfile, withProfile,
} from "#profiles"; } from "#profiles";
import { import { readRuntimeManifest, type RuntimeOutcome, type RuntimeProfile } from "#runtime";
readRuntimeManifest,
type RuntimeOutcome,
type RuntimeProfile,
} from "#runtime";
interface AttemptResult { interface AttemptResult {
body: string; body: string;
@@ -67,17 +58,15 @@ interface RenderedPrompt {
const env = (name: string): string => { const env = (name: string): string => {
const value = process.env[name]; const value = process.env[name];
if (value === undefined) { if (value === undefined) throw new Error(`${name} is not set`);
throw new Error(`${name} is not set`);
}
return value; return value;
}; };
function definedEnvironment(): Map<string, string> { function definedEnvironment(): NodeJS.ProcessEnv {
const result = new Map<string, string>(); const result: NodeJS.ProcessEnv = {};
for (const [name, value] of Object.entries(process.env)) { for (const [name, value] of Object.entries(process.env)) {
if (value !== undefined) { if (value !== undefined) {
result.set(name, value); result[name] = value;
} }
} }
return result; return result;
@@ -115,36 +104,21 @@ async function postAuthorComment(body: string): Promise<void> {
} }
async function runRoot(command: string, args: string[]): Promise<void> { async function runRoot(command: string, args: string[]): Promise<void> {
const code = await exitCode( const code = await exitCode(spawn(command, args, { env: PROCESS_ENV, stdio: "ignore" }));
spawn(command, args, { if (code !== 0) throw new Error(`${command} ${args[0]} exited with ${code}`);
env: Object.fromEntries(PROCESS_ENV),
stdio: "ignore",
}),
);
if (code !== 0) {
throw new Error(`${command} ${args[0]} exited with ${code}`);
}
} }
async function configureGitAuthor(): Promise<void> { async function configureGitAuthor(): Promise<void> {
const userResponse = await gitea("user"); const user: unknown = await (await gitea("user")).json();
const user: unknown = await userResponse.json(); if (!isObject(user) || typeof user["login"] !== "string" || typeof user["email"] !== "string") {
const login = field(user, "login"); throw new Error("user: unexpected Gitea response");
const email = field(user, "email");
if (typeof login !== "string" || typeof email !== "string") {
throw new TypeError("user: unexpected Gitea response");
} }
await runRoot("git", ["config", "user.name", login]); await runRoot("git", ["config", "user.name", user["login"]]);
await runRoot("git", ["config", "user.email", email]); await runRoot("git", ["config", "user.email", user["email"]]);
} }
async function readProfileToken( async function readProfileToken(profile: RuntimeProfile): Promise<string | null> {
profile: RuntimeProfile, const token = profile.tokenFile === null ? null : await readFile(profile.tokenFile, "utf8");
): Promise<string | null> {
const token =
profile.tokenFile === null
? null
: await readFile(profile.tokenFile, "utf8");
return token; return token;
} }
@@ -156,27 +130,13 @@ async function runAgentCommand(
): Promise<void> { ): Promise<void> {
const child = spawn(command, args, { const child = spawn(command, args, {
cwd: WORKSPACE, cwd: WORKSPACE,
env: Object.fromEntries(agentEnvironment(PROCESS_ENV, profile, token)), env: agentEnvironment(PROCESS_ENV, profile, token),
uid: profile.uid, uid: profile.uid,
gid: profile.gid, gid: profile.gid,
stdio: "ignore", stdio: "ignore",
}); });
const code = await exitCode(child); const code = await exitCode(child);
if (code !== 0) { if (code !== 0) throw new Error(`${command} ${args[0]} exited with ${code}`);
throw new Error(`${command} ${args[0]} exited with ${code}`);
}
}
// The agent name the skills installer knows each profile type by.
function skillsAgent(type: RuntimeProfile["type"]): string {
switch (type) {
case "CLAUDE":
return "claude-code";
case "CODEX":
return "codex";
case "OPENCODE":
return "opencode";
}
} }
async function prepareProfile(profile: RuntimeProfile): Promise<void> { async function prepareProfile(profile: RuntimeProfile): Promise<void> {
@@ -192,68 +152,50 @@ async function prepareProfile(profile: RuntimeProfile): Promise<void> {
...SKILLS_INSTALL.split(" "), ...SKILLS_INSTALL.split(" "),
"--global", "--global",
"--agent", "--agent",
skillsAgent(profile.type), profile.type === "claude" ? "claude-code" : profile.type,
"--yes", "--yes",
]); ]);
} }
// One issue comment as the prompt quotes it. // One issue comment as the prompt quotes it.
function formatComment(comment: unknown): string { function formatComment(comment: unknown): string {
const login = field(field(comment, "user"), "login"); const { user, created_at: createdAt, body } = isObject(comment) ? comment : {};
const createdAt = field(comment, "created_at"); const login = isObject(user) ? user["login"] : undefined;
const body = field(comment, "body");
return `## ${String(login)} at ${String(createdAt)}\n\n${String(body)}\n`; return `## ${String(login)} at ${String(createdAt)}\n\n${String(body)}\n`;
} }
async function renderPrompt(profile: RuntimeProfile): Promise<RenderedPrompt> { async function renderPrompt(profile: RuntimeProfile): Promise<RenderedPrompt> {
const reviewPath = await makeProfileFile(profile, "review.md"); const reviewPath = await makeProfileFile(profile, "review.md");
const anchorsPath = await makeProfileFile(profile, "anchors.json"); const anchorsPath = await makeProfileFile(profile, "anchors.json");
const commentsResponse = await gitea( const comments: unknown = await (
`repos/${REPO}/issues/${INDEX}/comments?limit=100`, await gitea(`repos/${REPO}/issues/${INDEX}/comments?limit=100`)
); ).json();
const comments: unknown = await commentsResponse.json();
if (!Array.isArray(comments)) { if (!Array.isArray(comments)) {
throw new TypeError("comments: unexpected Gitea response"); throw new TypeError("comments: unexpected Gitea response");
} }
const rulesResponse = await gitea(RULES_PATH); const values: NodeJS.ProcessEnv = {
const codeRules = await rulesResponse.text(); COMMENT: env("COMMENT"),
const values = new Map<string, string>([ ISSUE_COMMENTS: comments.map((comment: unknown) => formatComment(comment)).join("\n"),
["COMMENT", env("COMMENT")], CODE_RULES: await (await gitea(RULES_PATH)).text(),
[ EVENT_NAME: EVENT,
"ISSUE_COMMENTS", GITEA_API_URL: API,
comments.map((comment: unknown) => formatComment(comment)).join("\n"), GITEA_REPOSITORY: REPO,
], ISSUE_INDEX: INDEX,
["CODE_RULES", codeRules], REVIEW_PATH: reviewPath,
["EVENT_NAME", EVENT], ANCHORS_PATH: anchorsPath,
["GITEA_API_URL", API], };
["GITEA_REPOSITORY", REPO], const template = await readFile(new URL("../../prompt.md", import.meta.url), "utf8");
["ISSUE_INDEX", INDEX],
["REVIEW_PATH", reviewPath],
["ANCHORS_PATH", anchorsPath],
]);
const template = await readFile(
new URL("../../prompt.md", import.meta.url),
"utf8",
);
return { return {
prompt: template.replaceAll( prompt: template.replaceAll(
/\$\{(?<name>\w+)\}/gu, /\$\{(\w+)\}/gu,
(match: string, ...args: unknown[]) => { (match: string, name: string) => values[name] ?? match,
const groups = args.at(-1);
const name = isObject(groups) ? field(groups, "name") : undefined;
return typeof name === "string" ? (values.get(name) ?? match) : match;
},
), ),
reviewPath, reviewPath,
anchorsPath, anchorsPath,
}; };
} }
async function runClaude( async function runClaude(profile: RuntimeProfile, token: string, prompt: string): Promise<string> {
profile: RuntimeProfile,
token: string,
prompt: string,
): Promise<string> {
const claude = spawn( const claude = spawn(
"claude", "claude",
[ [
@@ -268,9 +210,10 @@ async function runClaude(
], ],
{ {
cwd: WORKSPACE, cwd: WORKSPACE,
env: Object.fromEntries( env: {
agentEnvironment(PROCESS_ENV, profile, token).set("IS_SANDBOX", "1"), ...agentEnvironment(PROCESS_ENV, profile, token),
), IS_SANDBOX: "1",
},
uid: profile.uid, uid: profile.uid,
gid: profile.gid, gid: profile.gid,
stdio: ["ignore", "pipe", "pipe"], stdio: ["ignore", "pipe", "pipe"],
@@ -287,36 +230,26 @@ async function runClaude(
console.error(part); console.error(part);
} }
})(); })();
for await (const line of createInterface({ for await (const line of createInterface({ input: claude.stdout, crlfDelay: Infinity })) {
input: claude.stdout,
crlfDelay: Infinity,
})) {
if (line !== "") { if (line !== "") {
const event: unknown = JSON.parse(line); const event: unknown = JSON.parse(line);
if (isObject(event)) { if (isObject(event)) {
const content = field(field(event, "message"), "content"); const content = isObject(event["message"]) ? event["message"]["content"] : undefined;
for (const part of Array.isArray(content) ? content : []) { for (const part of Array.isArray(content) ? content : []) {
if (isObject(part)) { if (isObject(part)) {
const text = const text = part["thinking"] ?? part["text"] ?? part["name"];
field(part, "thinking") ??
field(part, "text") ??
field(part, "name");
if (typeof text === "string" && text !== "") { if (typeof text === "string" && text !== "") {
console.log(text); console.log(text);
} }
} }
} }
if (field(event, "type") === "result") { if (event["type"] === "result") {
const isError = field(event, "is_error"); const { is_error: isError, result: answer, subtype, api_error_status: apiStatus } = event;
const answer = field(event, "result");
const subtype = field(event, "subtype");
const apiStatus = field(event, "api_error_status");
result = { result = {
isError: typeof isError === "boolean" ? isError : undefined, isError: typeof isError === "boolean" ? isError : undefined,
result: typeof answer === "string" ? answer : undefined, result: typeof answer === "string" ? answer : undefined,
subtype: String(subtype), subtype: String(subtype),
apiErrorStatus: apiErrorStatus: typeof apiStatus === "number" ? apiStatus : undefined,
typeof apiStatus === "number" ? apiStatus : undefined,
}; };
} }
} }
@@ -324,18 +257,14 @@ async function runClaude(
} }
const [code] = await Promise.all([status, copyError]); const [code] = await Promise.all([status, copyError]);
if (result?.isError === true) { if (result?.isError === true) {
const failure = new Error( const failure = new Error(result.result ?? `claude ended with ${result.subtype}`);
result.result ?? `claude ended with ${result.subtype}`,
);
if (isClaudeAuthFailure(result)) { if (isClaudeAuthFailure(result)) {
throw new AgentAuthError("claude sign-in failed", { cause: failure }); throw new AgentAuthError("claude sign-in failed", { cause: failure });
} }
throw failure; throw failure;
} }
if (result?.result === undefined) { if (result?.result === undefined) {
throw new Error( throw new Error(error.trim() || `claude ended with ${result?.subtype ?? "no result"}`);
error.trim() || `claude ended with ${result?.subtype ?? "no result"}`,
);
} }
if (code !== 0) { if (code !== 0) {
throw new Error(error.trim() || `claude exited with ${code}`); throw new Error(error.trim() || `claude exited with ${code}`);
@@ -343,13 +272,28 @@ async function runClaude(
return result.result; return result.result;
} }
// Polls every 100 ms until the login prints something, failing if it exits first.
async function pollForInstructions(
shownText: () => string,
status: Promise<number>,
): Promise<void> {
if (shownText().trim() !== "") {
return;
}
const exited = await Promise.race([status.then(() => true), sleep(100, false)]);
if (exited) {
throw new AgentAuthError("AI bot login produced no instructions");
}
await pollForInstructions(shownText, status);
}
async function codexDeviceLogin( async function codexDeviceLogin(
profile: RuntimeProfile, profile: RuntimeProfile,
environment: ReadonlyMap<string, string>, environment: NodeJS.ProcessEnv,
): Promise<void> { ): Promise<void> {
const login = spawn("codex", ["login", "--device-auth"], { const login = spawn("codex", ["login", "--device-auth"], {
cwd: WORKSPACE, cwd: WORKSPACE,
env: Object.fromEntries(environment), env: environment,
uid: profile.uid, uid: profile.uid,
gid: profile.gid, gid: profile.gid,
stdio: ["ignore", "pipe", "pipe"], stdio: ["ignore", "pipe", "pipe"],
@@ -364,15 +308,7 @@ async function codexDeviceLogin(
}; };
const drained = Promise.all([collect(login.stdout), collect(login.stderr)]); const drained = Promise.all([collect(login.stdout), collect(login.stderr)]);
await sleep(3000); await sleep(3000);
while (shown.trim() === "") { await pollForInstructions(() => shown, status);
const exited = await Promise.race([
status.then(() => true),
sleep(100, false),
]);
if (exited) {
throw new AgentAuthError("AI bot login produced no instructions");
}
}
await postAuthorComment(withProfile(shown, profile)); await postAuthorComment(withProfile(shown, profile));
const [code] = await Promise.all([status, drained]); const [code] = await Promise.all([status, drained]);
if (code !== 0) { if (code !== 0) {
@@ -382,12 +318,12 @@ async function codexDeviceLogin(
async function codexApiLogin( async function codexApiLogin(
profile: RuntimeProfile, profile: RuntimeProfile,
environment: ReadonlyMap<string, string>, environment: NodeJS.ProcessEnv,
token: string, token: string,
): Promise<void> { ): Promise<void> {
const login = spawn("codex", ["login", "--with-api-key"], { const login = spawn("codex", ["login", "--with-api-key"], {
cwd: WORKSPACE, cwd: WORKSPACE,
env: Object.fromEntries(environment), env: environment,
uid: profile.uid, uid: profile.uid,
gid: profile.gid, gid: profile.gid,
stdio: ["pipe", "inherit", "pipe"], stdio: ["pipe", "inherit", "pipe"],
@@ -401,10 +337,7 @@ async function codexApiLogin(
} }
} }
async function makeProfileFile( async function makeProfileFile(profile: RuntimeProfile, name: string): Promise<string> {
profile: RuntimeProfile,
name: string,
): Promise<string> {
const path = `${profile.home}/${name}`; const path = `${profile.home}/${name}`;
await writeFile(path, "", { mode: 0o600 }); await writeFile(path, "", { mode: 0o600 });
await chmod(path, 0o600); await chmod(path, 0o600);
@@ -417,22 +350,19 @@ async function runCodex(
prompt: string, prompt: string,
authentication: CodexAuthentication, authentication: CodexAuthentication,
): Promise<string> { ): Promise<string> {
const token = const token = authentication.kind === "api-key" ? authentication.token : undefined;
authentication.kind === "api-key" ? authentication.token : undefined;
const environment = agentEnvironment(PROCESS_ENV, profile, token); const environment = agentEnvironment(PROCESS_ENV, profile, token);
if (authentication.kind === "api-key") { if (authentication.kind === "api-key") {
await codexApiLogin(profile, environment, authentication.token); await codexApiLogin(profile, environment, authentication.token);
} else { } else {
const check = spawn("codex", ["login", "status"], { const check = spawn("codex", ["login", "status"], {
cwd: WORKSPACE, cwd: WORKSPACE,
env: Object.fromEntries(environment), env: environment,
uid: profile.uid, uid: profile.uid,
gid: profile.gid, gid: profile.gid,
stdio: "ignore", stdio: "ignore",
}); });
if ((await exitCode(check)) !== 0) { if ((await exitCode(check)) !== 0) await codexDeviceLogin(profile, environment);
await codexDeviceLogin(profile, environment);
}
} }
const outputPath = await makeProfileFile(profile, "result.md"); const outputPath = await makeProfileFile(profile, "result.md");
const attempt = async (): Promise<CommandResult> => { const attempt = async (): Promise<CommandResult> => {
@@ -449,7 +379,7 @@ async function runCodex(
], ],
{ {
cwd: WORKSPACE, cwd: WORKSPACE,
env: Object.fromEntries(environment), env: environment,
uid: profile.uid, uid: profile.uid,
gid: profile.gid, gid: profile.gid,
stdio: ["ignore", "inherit", "pipe"], stdio: ["ignore", "inherit", "pipe"],
@@ -474,9 +404,7 @@ async function runCodex(
await codexDeviceLogin(profile, environment); await codexDeviceLogin(profile, environment);
}); });
if (result.code !== 0) { if (result.code !== 0) {
const failure = new Error( const failure = new Error(result.error.trim() || `codex exited with ${result.code}`);
result.error.trim() || `codex exited with ${result.code}`,
);
if (isCodexAuthFailure(result.error)) { if (isCodexAuthFailure(result.error)) {
throw new AgentAuthError("codex sign-in failed", { cause: failure }); throw new AgentAuthError("codex sign-in failed", { cause: failure });
} }
@@ -492,7 +420,7 @@ async function runOpenCode(
): Promise<string> { ): Promise<string> {
const child = spawn("opencode", openCodeArgs(profile.model, prompt), { const child = spawn("opencode", openCodeArgs(profile.model, prompt), {
cwd: WORKSPACE, cwd: WORKSPACE,
env: Object.fromEntries(agentEnvironment(PROCESS_ENV, profile, token)), env: agentEnvironment(PROCESS_ENV, profile, token),
uid: profile.uid, uid: profile.uid,
gid: profile.gid, gid: profile.gid,
stdio: ["ignore", "pipe", "pipe"], stdio: ["ignore", "pipe", "pipe"],
@@ -501,28 +429,20 @@ async function runOpenCode(
const collected = collectOpenCodeOutput( const collected = collectOpenCodeOutput(
child.stdout, child.stdout,
child.stderr, child.stderr,
async (chunk) => { (chunk) => echo(process.stdout, chunk),
await echo(process.stdout, chunk); (chunk) => echo(process.stderr, chunk),
},
async (chunk) => {
await echo(process.stderr, chunk);
},
); );
const [code, streams] = await Promise.all([status, collected]); const [code, streams] = await Promise.all([status, collected]);
const error = streams.stderr.trim(); const error = streams.stderr.trim();
if (code !== 0) { if (code !== 0) {
throw ( throw openCodeError(streams.stdout) ?? new Error(error || `opencode exited with ${code}`);
openCodeError(streams.stdout) ??
new Error(error || `opencode exited with ${code}`)
);
} }
return parseOpenCodeEvents(streams.stdout); return parseOpenCodeEvents(streams.stdout);
} }
async function runProfile(profile: RuntimeProfile): Promise<AttemptResult> { async function runProfile(profile: RuntimeProfile): Promise<AttemptResult> {
const token = await readProfileToken(profile); const token = await readProfileToken(profile);
const authentication = const authentication = profile.type === "codex" ? codexAuthentication(token ?? undefined) : null;
profile.type === "CODEX" ? codexAuthentication(token ?? undefined) : null;
let stagedCodexAuth: string | null = null; let stagedCodexAuth: string | null = null;
let body: string | null = null; let body: string | null = null;
let resultPath: string | null = null; let resultPath: string | null = null;
@@ -530,20 +450,15 @@ async function runProfile(profile: RuntimeProfile): Promise<AttemptResult> {
let anchorsPath: string | null = null; let anchorsPath: string | null = null;
try { try {
if (authentication?.kind === "persistent") { if (authentication?.kind === "persistent") {
stagedCodexAuth = await stageCodexAuth( stagedCodexAuth = await stageCodexAuth(CODEX_AUTH, profile.home, profile.uid, profile.gid);
CODEX_AUTH,
profile.home,
profile.uid,
profile.gid,
);
} }
await prepareProfile(profile); await prepareProfile(profile);
const rendered = await renderPrompt(profile); const rendered = await renderPrompt(profile);
reviewPath = rendered.reviewPath; reviewPath = rendered.reviewPath;
anchorsPath = rendered.anchorsPath; anchorsPath = rendered.anchorsPath;
if (profile.type === "CLAUDE") { if (profile.type === "claude") {
body = await runClaude(profile, token ?? "", rendered.prompt); body = await runClaude(profile, token ?? "", rendered.prompt);
} else if (profile.type === "CODEX") { } else if (profile.type === "codex") {
resultPath = await runCodex( resultPath = await runCodex(
profile, profile,
rendered.prompt, rendered.prompt,
@@ -558,9 +473,7 @@ async function runProfile(profile: RuntimeProfile): Promise<AttemptResult> {
await persistCodexAuth(stagedCodexAuth, CODEX_AUTH); await persistCodexAuth(stagedCodexAuth, CODEX_AUTH);
} }
} }
if (resultPath !== null) { if (resultPath !== null) body = await readProfileFile(profile, resultPath);
body = await readProfileFile(profile, resultPath);
}
if (body === null || reviewPath === null || anchorsPath === null) { if (body === null || reviewPath === null || anchorsPath === null) {
throw new Error("agent attempt produced no result"); throw new Error("agent attempt produced no result");
} }
+17 -43
View File
@@ -1,14 +1,10 @@
import { expect, test } from "vite-plus/test"; import { expect, test } from "vite-plus/test";
import { import { decryptCredential, encryptCredential, parseCredentials } from "./credentials.ts";
decryptCredential,
encryptCredential,
parseCredentials,
} from "./credentials.ts";
const MASTER_KEY = "AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8"; const MASTER_KEY = "AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8";
const OTHER_KEY = "AQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQE"; const OTHER_KEY = "AQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQE";
const NONCE = Uint8Array.from({ length: 12 }, (_value, index) => index + 32); const NONCE = Uint8Array.from({ length: 12 }, (_, index) => index + 32);
const ENCRYPTED = "v1:ICEiIyQlJicoKSor:oV_FAgnsN3p1FyegJxwGVdyjfyPio6qDeSUwbA"; const ENCRYPTED = "v1:ICEiIyQlJicoKSor:oV_FAgnsN3p1FyegJxwGVdyjfyPio6qDeSUwbA";
test("decrypts a known AES-256-GCM credential", async () => { test("decrypts a known AES-256-GCM credential", async () => {
@@ -16,21 +12,16 @@ test("decrypts a known AES-256-GCM credential", async () => {
}); });
test("encrypts a credential with a fresh supplied nonce", async () => { test("encrypts a credential with a fresh supplied nonce", async () => {
expect( expect(await encryptCredential("secret-token", MASTER_KEY, NONCE)).toStrictEqual(ENCRYPTED);
await encryptCredential("secret-token", MASTER_KEY, NONCE),
).toStrictEqual(ENCRYPTED);
}); });
test("rejects a credential encrypted by another master key", async () => { test("rejects a credential encrypted by another master key", async () => {
await expect(decryptCredential(ENCRYPTED, OTHER_KEY)).rejects.toThrow(); await expect(() => decryptCredential(ENCRYPTED, OTHER_KEY)).rejects.toThrow();
}); });
test("rejects a credential with a nonstandard nonce", async () => { test("rejects a credential with a nonstandard nonce", async () => {
await expect( await expect(() =>
decryptCredential( decryptCredential("v1:AA:oV_FAgnsN3p1FyegJxwGVdyjfyPio6qDeSUwbA", MASTER_KEY),
"v1:AA:oV_FAgnsN3p1FyegJxwGVdyjfyPio6qDeSUwbA",
MASTER_KEY,
),
).rejects.toThrow("nonce must be 12 bytes"); ).rejects.toThrow("nonce must be 12 bytes");
}); });
@@ -40,9 +31,9 @@ test("decrypts the central reviewer token and ordered profiles", async () => {
JSON.stringify({ JSON.stringify({
"reviewer-token": ENCRYPTED, "reviewer-token": ENCRYPTED,
profiles: [ profiles: [
{ type: "CODEX", model: "gpt-custom" }, { type: "codex", model: "gpt-custom" },
{ type: "CLAUDE", token: ENCRYPTED }, { type: "claude", token: ENCRYPTED },
{ type: "OPENCODE", token: ENCRYPTED }, { type: "opencode", token: ENCRYPTED },
], ],
}), }),
MASTER_KEY, MASTER_KEY,
@@ -50,14 +41,14 @@ test("decrypts the central reviewer token and ordered profiles", async () => {
).toStrictEqual({ ).toStrictEqual({
reviewerToken: "secret-token", reviewerToken: "secret-token",
profiles: [ profiles: [
{ type: "CODEX", model: "gpt-custom" }, { type: "codex", model: "gpt-custom" },
{ {
type: "CLAUDE", type: "claude",
model: "claude-sonnet-5", model: "claude-sonnet-5",
token: "secret-token", token: "secret-token",
}, },
{ {
type: "OPENCODE", type: "opencode",
model: "openrouter/qwen/qwen3.8-27b", model: "openrouter/qwen/qwen3.8-27b",
token: "secret-token", token: "secret-token",
}, },
@@ -66,30 +57,13 @@ test("decrypts the central reviewer token and ordered profiles", async () => {
}); });
test("rejects malformed central credentials", async () => { test("rejects malformed central credentials", async () => {
await expect( await expect(() => parseCredentials('{"profiles": []}', MASTER_KEY)).rejects.toThrow(
parseCredentials('{"profiles": []}', MASTER_KEY), "reviewer-token",
).rejects.toThrow("reviewer-token"); );
await expect( await expect(() =>
parseCredentials( parseCredentials(
JSON.stringify({ JSON.stringify({ "reviewer-token": ENCRYPTED, profiles: [{ type: "claude" }] }),
"reviewer-token": ENCRYPTED,
profiles: [{ type: "CLAUDE" }],
}),
MASTER_KEY, MASTER_KEY,
), ),
).rejects.toThrow("profiles[0].token"); ).rejects.toThrow("profiles[0].token");
}); });
test("reads lowercase profile types from older credentials", async () => {
const credentials = await parseCredentials(
JSON.stringify({
"reviewer-token": ENCRYPTED,
profiles: [{ type: "codex" }, { type: "claude", token: ENCRYPTED }],
}),
MASTER_KEY,
);
expect(credentials.profiles.map(({ type }) => type)).toStrictEqual([
"CODEX",
"CLAUDE",
]);
});
+32 -91
View File
@@ -1,20 +1,20 @@
import { webcrypto } from "node:crypto"; import { webcrypto } from "node:crypto";
import { field, isMapping } from "#common"; import { isMapping } from "#common";
import type { BotProfile } from "#profiles"; import type { BotProfile } from "#profiles";
// The model a profile runs when profiles.json names none. interface DefaultModels {
function defaultModel(type: BotProfile["type"]): string { claude: string;
switch (type) { codex: string;
case "CLAUDE": opencode: string;
return "claude-sonnet-5";
case "CODEX":
return "gpt-5.6-terra";
case "OPENCODE":
return "openrouter/qwen/qwen3.8-27b";
}
} }
const DEFAULT_MODELS: DefaultModels = {
claude: "claude-sonnet-5",
codex: "gpt-5.6-terra",
opencode: "openrouter/qwen/qwen3.8-27b",
};
export interface BotCredentials { export interface BotCredentials {
reviewerToken: string; reviewerToken: string;
profiles: BotProfile[]; profiles: BotProfile[];
@@ -23,61 +23,31 @@ export interface BotCredentials {
function decodeBase64Url(value: string): Uint8Array { function decodeBase64Url(value: string): Uint8Array {
const base64 = value.replaceAll("-", "+").replaceAll("_", "/"); const base64 = value.replaceAll("-", "+").replaceAll("_", "/");
const padded = base64.padEnd(Math.ceil(base64.length / 4) * 4, "="); const padded = base64.padEnd(Math.ceil(base64.length / 4) * 4, "=");
return Uint8Array.from( return Uint8Array.from(atob(padded), (character) => character.codePointAt(0) ?? 0);
atob(padded),
(character) => character.codePointAt(0) ?? 0,
);
} }
function encodeBase64Url(value: Uint8Array): string { function encodeBase64Url(value: Uint8Array): string {
const binary = Array.from(value, (byte) => String.fromCodePoint(byte)).join( const binary = Array.from(value, (byte) => String.fromCodePoint(byte)).join("");
"", return btoa(binary).replaceAll("+", "-").replaceAll("/", "_").replaceAll("=", "");
);
return btoa(binary)
.replaceAll("+", "-")
.replaceAll("/", "_")
.replaceAll("=", "");
} }
const buffer = (value: Uint8Array): ArrayBuffer => const buffer = (value: Uint8Array): ArrayBuffer => Uint8Array.from(value).buffer;
Uint8Array.from(value).buffer;
async function importMasterKey( function importMasterKey(encoded: string, usage: webcrypto.KeyUsage): Promise<webcrypto.CryptoKey> {
encoded: string,
usage: webcrypto.KeyUsage,
): Promise<webcrypto.CryptoKey> {
const bytes = decodeBase64Url(encoded); const bytes = decodeBase64Url(encoded);
if (bytes.length !== 32) { if (bytes.length !== 32) {
throw new Error("master-key must be 32 bytes encoded as base64url"); throw new Error("master-key must be 32 bytes encoded as base64url");
} }
const key = await webcrypto.subtle.importKey( return webcrypto.subtle.importKey("raw", buffer(bytes), "AES-GCM", false, [usage]);
"raw",
buffer(bytes),
"AES-GCM",
false,
[usage],
);
return key;
} }
export async function decryptCredential( export async function decryptCredential(encrypted: string, masterKey: string): Promise<string> {
encrypted: string, const [version, encodedNonce = "", encodedCiphertext = "", extra = ""] = encrypted.split(":");
masterKey: string, if (version !== "v1" || encodedNonce === "" || encodedCiphertext === "" || extra !== "") {
): Promise<string> {
const [version, encodedNonce = "", encodedCiphertext = "", extra = ""] =
encrypted.split(":");
if (
version !== "v1" ||
encodedNonce === "" ||
encodedCiphertext === "" ||
extra !== ""
) {
throw new Error("credential must use v1:<nonce>:<ciphertext>"); throw new Error("credential must use v1:<nonce>:<ciphertext>");
} }
const nonce = decodeBase64Url(encodedNonce); const nonce = decodeBase64Url(encodedNonce);
if (nonce.length !== 12) { if (nonce.length !== 12) throw new Error("credential nonce must be 12 bytes");
throw new Error("credential nonce must be 12 bytes");
}
const plaintext = await webcrypto.subtle.decrypt( const plaintext = await webcrypto.subtle.decrypt(
{ name: "AES-GCM", iv: buffer(nonce) }, { name: "AES-GCM", iv: buffer(nonce) },
await importMasterKey(masterKey, "decrypt"), await importMasterKey(masterKey, "decrypt"),
@@ -91,9 +61,7 @@ export async function encryptCredential(
masterKey: string, masterKey: string,
nonce: Uint8Array = webcrypto.getRandomValues(new Uint8Array(12)), nonce: Uint8Array = webcrypto.getRandomValues(new Uint8Array(12)),
): Promise<string> { ): Promise<string> {
if (nonce.length !== 12) { if (nonce.length !== 12) throw new Error("AES-GCM nonce must be 12 bytes");
throw new Error("AES-GCM nonce must be 12 bytes");
}
const ciphertext = await webcrypto.subtle.encrypt( const ciphertext = await webcrypto.subtle.encrypt(
{ name: "AES-GCM", iv: buffer(nonce) }, { name: "AES-GCM", iv: buffer(nonce) },
await importMasterKey(masterKey, "encrypt"), await importMasterKey(masterKey, "encrypt"),
@@ -102,22 +70,7 @@ export async function encryptCredential(
return `v1:${encodeBase64Url(nonce)}:${encodeBase64Url(new Uint8Array(ciphertext))}`; return `v1:${encodeBase64Url(nonce)}:${encodeBase64Url(new Uint8Array(ciphertext))}`;
} }
// profiles.json files written before the UPPER_SNAKE switch spell types in lowercase. async function parseProfile(entry: unknown, index: number, masterKey: string): Promise<BotProfile> {
const OLD_PROFILE_TYPES = new Map<unknown, BotProfile["type"]>([
["claude", "CLAUDE"],
["codex", "CODEX"],
["opencode", "OPENCODE"],
]);
function currentSpelling(type: unknown): unknown {
return OLD_PROFILE_TYPES.get(type) ?? type;
}
async function parseProfile(
entry: unknown,
index: number,
masterKey: string,
): Promise<BotProfile> {
const at = `profiles[${index}]`; const at = `profiles[${index}]`;
if (!isMapping(entry)) { if (!isMapping(entry)) {
throw new TypeError(`${at}: expected a mapping`); throw new TypeError(`${at}: expected a mapping`);
@@ -127,16 +80,14 @@ async function parseProfile(
throw new Error(`${at}.${key}: unknown field`); throw new Error(`${at}.${key}: unknown field`);
} }
} }
const type = currentSpelling(field(entry, "type")); const { type, model, token } = entry;
const model = field(entry, "model"); if (type !== "claude" && type !== "codex" && type !== "opencode") {
const token = field(entry, "token"); throw new Error(`${at}.type: expected "claude", "codex", or "opencode"`);
if (type !== "CLAUDE" && type !== "CODEX" && type !== "OPENCODE") {
throw new Error(`${at}.type: expected "CLAUDE", "CODEX", or "OPENCODE"`);
} }
if (model !== undefined && (typeof model !== "string" || model === "")) { if (model !== undefined && (typeof model !== "string" || model === "")) {
throw new Error(`${at}.model: expected a model name`); throw new Error(`${at}.model: expected a model name`);
} }
if ((type === "CLAUDE" || type === "OPENCODE") && typeof token !== "string") { if ((type === "claude" || type === "opencode") && typeof token !== "string") {
throw new Error(`${at}.token: expected an encrypted credential`); throw new Error(`${at}.token: expected an encrypted credential`);
} }
if (token !== undefined && typeof token !== "string") { if (token !== undefined && typeof token !== "string") {
@@ -144,17 +95,14 @@ async function parseProfile(
} }
return { return {
type, type,
model: model ?? defaultModel(type), model: model ?? DEFAULT_MODELS[type],
...(typeof token === "string" && { ...(typeof token === "string" && {
token: await decryptCredential(token, masterKey), token: await decryptCredential(token, masterKey),
}), }),
}; };
} }
export async function parseCredentials( export async function parseCredentials(text: string, masterKey: string): Promise<BotCredentials> {
text: string,
masterKey: string,
): Promise<BotCredentials> {
const value: unknown = JSON.parse(text); const value: unknown = JSON.parse(text);
if (!isMapping(value)) { if (!isMapping(value)) {
throw new TypeError("credentials must be a mapping"); throw new TypeError("credentials must be a mapping");
@@ -164,8 +112,7 @@ export async function parseCredentials(
throw new Error(`${key}: unknown field`); throw new Error(`${key}: unknown field`);
} }
} }
const reviewerToken = field(value, "reviewer-token"); const { "reviewer-token": reviewerToken, profiles } = value;
const profiles = field(value, "profiles");
if (typeof reviewerToken !== "string") { if (typeof reviewerToken !== "string") {
throw new TypeError("reviewer-token: expected an encrypted credential"); throw new TypeError("reviewer-token: expected an encrypted credential");
} }
@@ -173,13 +120,7 @@ export async function parseCredentials(
throw new Error("profiles must contain at least one profile"); throw new Error("profiles must contain at least one profile");
} }
const parsed = await Promise.all( const parsed = await Promise.all(
profiles.map(async (entry: unknown, index) => { profiles.map((entry: unknown, index) => parseProfile(entry, index, masterKey)),
const profile = await parseProfile(entry, index, masterKey);
return profile;
}),
); );
return { return { reviewerToken: await decryptCredential(reviewerToken, masterKey), profiles: parsed };
reviewerToken: await decryptCredential(reviewerToken, masterKey),
profiles: parsed,
};
} }
+74 -102
View File
@@ -1,12 +1,5 @@
import { spawnSync } from "node:child_process"; import { spawnSync } from "node:child_process";
import { import { chmod, readdir, readFile, rm, stat, writeFile } from "node:fs/promises";
chmod,
readdir,
readFile,
rm,
stat,
writeFile,
} from "node:fs/promises";
import process from "node:process"; import process from "node:process";
import { fileURLToPath } from "node:url"; import { fileURLToPath } from "node:url";
import { assert, expect, test } from "vite-plus/test"; import { assert, expect, test } from "vite-plus/test";
@@ -19,111 +12,90 @@ const MASTER_KEY = "AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8";
const ENCRYPTED = "v1:ICEiIyQlJicoKSor:oV_FAgnsN3p1FyegJxwGVdyjfyPio6qDeSUwbA"; const ENCRYPTED = "v1:ICEiIyQlJicoKSor:oV_FAgnsN3p1FyegJxwGVdyjfyPio6qDeSUwbA";
// Runs `command` as the profile's user, from the root directory. // Runs `command` as the profile's user, from the root directory.
function runAs( function runAs(profile: RuntimeProfile, command: string, path: string): boolean {
profile: RuntimeProfile, const result = spawnSync(command, [path], { cwd: "/", uid: profile.uid, gid: profile.gid });
command: string,
path: string,
): boolean {
const result = spawnSync(command, [path], {
cwd: "/",
uid: profile.uid,
gid: profile.gid,
});
return result.status === 0; return result.status === 0;
} }
async function expectPrivate( async function expectPrivate(path: string, uid: number, mode: number): Promise<void> {
path: string,
uid: number,
mode: number,
): Promise<void> {
const info = await stat(path); const info = await stat(path);
expect(info.uid).toStrictEqual(uid); expect(info.uid).toStrictEqual(uid);
expect(info.mode & 0o777).toBe(mode); expect(info.mode & 0o777).toBe(mode);
} }
test.skipIf(!IS_ROOT)( test.skipIf(!IS_ROOT)("prepares root-only reviewer and isolated profile credentials", async () => {
"prepares root-only reviewer and isolated profile credentials", const root = await makeTempDir();
async () => { await chmod(root, 0o711);
const root = await makeTempDir(); const action = await makeTempDir();
await chmod(root, 0o711); try {
const action = await makeTempDir(); await writeFile(
try { `${action}/profiles.json`,
await writeFile( JSON.stringify({
`${action}/profiles.json`, "reviewer-token": ENCRYPTED,
JSON.stringify({ profiles: [{ type: "claude", token: ENCRYPTED }, { type: "codex" }],
"reviewer-token": ENCRYPTED, }),
profiles: [{ type: "CLAUDE", token: ENCRYPTED }, { type: "CODEX" }], );
}),
);
const manifest = await prepareRuntime(action, root, MASTER_KEY); const manifest = await prepareRuntime(action, root, MASTER_KEY);
const serialized = await readFile(manifest.manifestPath, "utf8"); const serialized = await readFile(manifest.manifestPath, "utf8");
assert(!serialized.includes("secret-token")); assert(!serialized.includes("secret-token"));
expect(await readFile(manifest.reviewerFile, "utf8")).toBe( expect(await readFile(manifest.reviewerFile, "utf8")).toBe("secret-token");
"secret-token", await expectPrivate(manifest.reviewerFile, 0, 0o600);
);
await expectPrivate(manifest.reviewerFile, 0, 0o600);
const [claude, codex] = manifest.profiles; const [claude, codex] = manifest.profiles;
assert(claude !== undefined && codex !== undefined); assert(claude !== undefined && codex !== undefined);
expect(claude.uid).not.toStrictEqual(codex.uid); expect(claude.uid).not.toStrictEqual(codex.uid);
await expectPrivate(claude.home, claude.uid, 0o700); await expectPrivate(claude.home, claude.uid, 0o700);
assert(claude.tokenFile !== null); assert(claude.tokenFile !== null);
expect(await readFile(claude.tokenFile, "utf8")).toBe("secret-token"); expect(await readFile(claude.tokenFile, "utf8")).toBe("secret-token");
await expectPrivate(claude.tokenFile, claude.uid, 0o600); await expectPrivate(claude.tokenFile, claude.uid, 0o600);
const codexHome = await stat(codex.home); expect((await stat(codex.home)).uid).toStrictEqual(codex.uid);
expect(codexHome.uid).toStrictEqual(codex.uid); expect(codex.tokenFile).toBe(null);
expect(codex.tokenFile).toBe(null);
const ownToken = spawnSync("/bin/cat", [claude.tokenFile], { const ownToken = spawnSync("/bin/cat", [claude.tokenFile], {
cwd: "/", cwd: "/",
uid: claude.uid, uid: claude.uid,
gid: claude.gid, gid: claude.gid,
encoding: "utf8", encoding: "utf8",
}); });
expect(ownToken.status).toBe(0); expect(ownToken.status).toBe(0);
expect(ownToken.stdout).toBe("secret-token"); expect(ownToken.stdout).toBe("secret-token");
expect(runAs(claude, "/bin/cat", manifest.reviewerFile)).toBe(false); expect(runAs(claude, "/bin/cat", manifest.reviewerFile)).toBe(false);
expect(runAs(claude, "/bin/ls", codex.home)).toBe(false); expect(runAs(claude, "/bin/ls", codex.home)).toBe(false);
} finally { } finally {
await rm(root, { recursive: true }); await rm(root, { recursive: true });
await rm(action, { recursive: true }); await rm(action, { recursive: true });
} }
}, });
);
test.skipIf(!IS_ROOT)( test.skipIf(!IS_ROOT)("removes prepared credentials when output publication fails", async () => {
"removes prepared credentials when output publication fails", const root = await makeTempDir();
async () => { const action = await makeTempDir();
const root = await makeTempDir(); try {
const action = await makeTempDir(); await writeFile(
try { `${action}/profiles.json`,
await writeFile( JSON.stringify({
`${action}/profiles.json`, "reviewer-token": ENCRYPTED,
JSON.stringify({ profiles: [{ type: "claude", token: ENCRYPTED }],
"reviewer-token": ENCRYPTED, }),
profiles: [{ type: "CLAUDE", token: ENCRYPTED }], );
}), const result = spawnSync(
); process.execPath,
const result = spawnSync( [fileURLToPath(new URL("../prepare/index.ts", import.meta.url))],
process.execPath, {
[fileURLToPath(new URL("../prepare/index.ts", import.meta.url))], env: {
{ ACTION_PATH: action,
env: Object.fromEntries([ RUNNER_TEMP: root,
["ACTION_PATH", action], BOT_AGENTS_MASTER_KEY: MASTER_KEY,
["RUNNER_TEMP", root], GITHUB_OUTPUT: action,
["BOT_AGENTS_MASTER_KEY", MASTER_KEY],
["GITHUB_OUTPUT", action],
]),
}, },
); },
);
expect(result.status).not.toBe(0); expect(result.status).not.toBe(0);
expect(await readdir(root)).toStrictEqual([]); expect(await readdir(root)).toStrictEqual([]);
} finally { } finally {
await rm(root, { recursive: true }); await rm(root, { recursive: true });
await rm(action, { recursive: true }); await rm(action, { recursive: true });
} }
}, });
);
+41 -54
View File
@@ -1,15 +1,7 @@
import { import { chmod, chown, mkdir, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
chmod, import { join } from "node:path";
chown,
mkdir,
mkdtemp,
readFile,
rm,
writeFile,
} from "node:fs/promises";
import nodePath from "node:path";
import { field, isMapping } from "#common"; import { isMapping } from "#common";
import type { ProfileFailure, ProfileIdentity } from "#profiles"; import type { ProfileFailure, ProfileIdentity } from "#profiles";
import { parseCredentials } from "./credentials.ts"; import { parseCredentials } from "./credentials.ts";
@@ -47,12 +39,7 @@ export interface RuntimeFailure {
export type RuntimeOutcome = RuntimeSuccess | RuntimeFailure; export type RuntimeOutcome = RuntimeSuccess | RuntimeFailure;
async function writePrivate( async function writePrivate(path: string, value: string, uid: number, gid: number): Promise<void> {
path: string,
value: string,
uid: number,
gid: number,
): Promise<void> {
await writeFile(path, value, { mode: 0o600 }); await writeFile(path, value, { mode: 0o600 });
await chmod(path, 0o600); await chmod(path, 0o600);
await chown(path, uid, gid); await chown(path, uid, gid);
@@ -64,47 +51,49 @@ export async function prepareRuntime(
masterKey: string, masterKey: string,
): Promise<RuntimeManifest> { ): Promise<RuntimeManifest> {
const credentials = await parseCredentials( const credentials = await parseCredentials(
await readFile(nodePath.join(actionPath, "profiles.json"), "utf8"), await readFile(join(actionPath, "profiles.json"), "utf8"),
masterKey, masterKey,
); );
const runtimeDir = await mkdtemp(nodePath.join(runtimeRoot, "bot-agents-")); const runtimeDir = await mkdtemp(join(runtimeRoot, "bot-agents-"));
try { try {
await chmod(runtimeDir, 0o711); await chmod(runtimeDir, 0o711);
const reviewerFile = nodePath.join(runtimeDir, "reviewer-token"); const reviewerFile = join(runtimeDir, "reviewer-token");
await writePrivate(reviewerFile, credentials.reviewerToken, 0, 0); await writePrivate(reviewerFile, credentials.reviewerToken, 0, 0);
// One profile at a time, in order, as each claims the next UID. // One profile at a time, in order, as each claims the next UID.
const profiles: RuntimeProfile[] = []; const profiles = await credentials.profiles.reduce<Promise<RuntimeProfile[]>>(
for (const [index, profile] of credentials.profiles.entries()) { async (previous, profile, index) => {
const uid = FIRST_PROFILE_UID + index; const prepared = await previous;
const home = nodePath.join(runtimeDir, `profile-${index}`); const uid = FIRST_PROFILE_UID + index;
await mkdir(home, { mode: 0o700 }); const home = join(runtimeDir, `profile-${index}`);
await chmod(home, 0o700); await mkdir(home, { mode: 0o700 });
await chown(home, uid, uid); await chmod(home, 0o700);
const tokenFile = await chown(home, uid, uid);
profile.token === undefined || profile.token === "" const tokenFile =
? null profile.token === undefined || profile.token === "" ? null : join(home, "token");
: nodePath.join(home, "token"); if (tokenFile !== null && profile.token !== undefined) {
if (tokenFile !== null && profile.token !== undefined) { await writePrivate(tokenFile, profile.token, uid, uid);
await writePrivate(tokenFile, profile.token, uid, uid); }
} prepared.push({
profiles.push({ index,
index, type: profile.type,
type: profile.type, model: profile.model,
model: profile.model, uid,
uid, gid: uid,
gid: uid, home,
home, tokenFile,
tokenFile, });
}); return prepared;
} },
Promise.resolve([]),
);
const manifestPath = nodePath.join(runtimeDir, "manifest.json"); const manifestPath = join(runtimeDir, "manifest.json");
const manifest: RuntimeManifest = { const manifest: RuntimeManifest = {
runtimeDir, runtimeDir,
manifestPath, manifestPath,
reviewerFile, reviewerFile,
outcomeFile: nodePath.join(runtimeDir, "outcome.json"), outcomeFile: join(runtimeDir, "outcome.json"),
profiles, profiles,
}; };
await writePrivate(manifestPath, JSON.stringify(manifest), 0, 0); await writePrivate(manifestPath, JSON.stringify(manifest), 0, 0);
@@ -118,17 +107,15 @@ export async function prepareRuntime(
function isRuntimeManifest(value: unknown): value is RuntimeManifest { function isRuntimeManifest(value: unknown): value is RuntimeManifest {
return ( return (
isMapping(value) && isMapping(value) &&
typeof field(value, "runtimeDir") === "string" && typeof value["runtimeDir"] === "string" &&
typeof field(value, "manifestPath") === "string" && typeof value["manifestPath"] === "string" &&
typeof field(value, "reviewerFile") === "string" && typeof value["reviewerFile"] === "string" &&
typeof field(value, "outcomeFile") === "string" && typeof value["outcomeFile"] === "string" &&
Array.isArray(field(value, "profiles")) Array.isArray(value["profiles"])
); );
} }
export async function readRuntimeManifest( export async function readRuntimeManifest(path: string): Promise<RuntimeManifest> {
path: string,
): Promise<RuntimeManifest> {
const value: unknown = JSON.parse(await readFile(path, "utf8")); const value: unknown = JSON.parse(await readFile(path, "utf8"));
if (!isRuntimeManifest(value)) { if (!isRuntimeManifest(value)) {
throw new Error(`${path}: invalid runtime manifest`); throw new Error(`${path}: invalid runtime manifest`);
+10 -28
View File
@@ -1,12 +1,12 @@
// Test support: the current user's IDs, a fresh temporary directory, the // Test support: the current user's IDs, a fresh temporary directory, and a
// inherited environment, and a plain command runner. It imports no source // plain command runner. It imports no source module, so the repository-level
// module, so the repository-level tests in tests/, which reach src/ only // tests in tests/, which reach src/ only through `#testing`, never touch
// through `#testing`, never touch internals. // internals.
import { spawn } from "node:child_process"; import { spawn } from "node:child_process";
import { once } from "node:events"; import { once } from "node:events";
import { mkdtemp } from "node:fs/promises"; import { mkdtemp } from "node:fs/promises";
import { tmpdir } from "node:os"; import { tmpdir } from "node:os";
import nodePath from "node:path"; import { join } from "node:path";
import process from "node:process"; import process from "node:process";
import { text } from "node:stream/consumers"; import { text } from "node:stream/consumers";
@@ -24,9 +24,8 @@ export const IS_ROOT: boolean = currentUid() === 0;
// Symlinks and POSIX modes, as these tests use them, need a Unix host. // Symlinks and POSIX modes, as these tests use them, need a Unix host.
export const IS_WINDOWS: boolean = process.platform === "win32"; export const IS_WINDOWS: boolean = process.platform === "win32";
export async function makeTempDir(): Promise<string> { export function makeTempDir(): Promise<string> {
const path = await mkdtemp(nodePath.join(tmpdir(), "bot-agents-test-")); return mkdtemp(join(tmpdir(), "bot-agents-test-"));
return path;
} }
export interface CommandResult { export interface CommandResult {
@@ -34,32 +33,15 @@ export interface CommandResult {
stderr: string; stderr: string;
} }
// This process's environment as a map from variable name to value.
export function inheritedEnvironment(): Map<string, string> {
const result = new Map<string, string>();
for (const [name, value] of Object.entries(process.env)) {
if (value !== undefined) {
result.set(name, value);
}
}
return result;
}
// Runs a command with stdin closed and only the given environment, and // Runs a command with stdin closed and only the given environment, and
// collects its stderr. // collects its stderr.
export async function runCommand( export async function runCommand(
command: string, command: string,
args: string[], args: string[],
env: ReadonlyMap<string, string>, env: NodeJS.ProcessEnv,
): Promise<CommandResult> { ): Promise<CommandResult> {
const child = spawn(command, args, { const child = spawn(command, args, { env, stdio: ["ignore", "ignore", "pipe"] });
env: Object.fromEntries(env), const [stderr, closed] = await Promise.all([text(child.stderr), once(child, "close")]);
stdio: ["ignore", "ignore", "pipe"],
});
const [stderr, closed] = await Promise.all([
text(child.stderr),
once(child, "close"),
]);
const exitCode: unknown = closed[0]; const exitCode: unknown = closed[0];
return { success: exitCode === 0, stderr }; return { success: exitCode === 0, stderr };
} }
+2 -8
View File
@@ -14,14 +14,8 @@ const PHASES: [phase: string, firstVariable: string][] = [
]; ];
test.each(PHASES)("Node loads the %s phase", async (phase, firstVariable) => { test.each(PHASES)("Node loads the %s phase", async (phase, firstVariable) => {
const path = fileURLToPath( const path = fileURLToPath(new URL(`../src/${phase}/index.ts`, import.meta.url));
new URL(`../src/${phase}/index.ts`, import.meta.url), const result = await runCommand(process.execPath, [path], { PATH: process.env["PATH"] ?? "" });
);
const result = await runCommand(
process.execPath,
[path],
new Map([["PATH", process.env["PATH"] ?? ""]]),
);
expect(result.success).toBe(false); expect(result.success).toBe(false);
expect(result.stderr).toContain(`${firstVariable} is not set`); expect(result.stderr).toContain(`${firstVariable} is not set`);
}); });
+55 -119
View File
@@ -3,27 +3,24 @@ import process from "node:process";
import { assert, expect, test } from "vite-plus/test"; import { assert, expect, test } from "vite-plus/test";
import { parse } from "yaml"; import { parse } from "yaml";
import { inheritedEnvironment, makeTempDir, runCommand } from "#testing"; import { makeTempDir, runCommand } from "#testing";
// A parsed YAML or JSON mapping, keyed by its dynamic field names. type JsonObject = NodeJS.Dict<unknown>;
type Mapping = Map<string, unknown>;
const mapping = (value: unknown, at: string): Mapping => { const isMapping = (value: unknown): value is JsonObject =>
assert( typeof value === "object" && value !== null && !Array.isArray(value);
typeof value === "object" && value !== null && !Array.isArray(value),
at, const mapping = (value: unknown, at: string): JsonObject => {
); assert(isMapping(value), at);
return new Map(Object.entries(value)); return value;
}; };
const sequence = (value: unknown, at: string): Mapping[] => { const sequence = (value: unknown, at: string): JsonObject[] => {
assert(Array.isArray(value), at); assert(Array.isArray(value), at);
return value.map((entry: unknown, index) => return value.map((entry: unknown, index) => mapping(entry, `${at}[${index}]`));
mapping(entry, `${at}[${index}]`),
);
}; };
async function yaml(path: string): Promise<Mapping> { async function yaml(path: string): Promise<JsonObject> {
const value: unknown = parse(await readFile(path, "utf8")); const value: unknown = parse(await readFile(path, "utf8"));
return mapping(value, path); return mapping(value, path);
} }
@@ -36,8 +33,8 @@ async function yamlFiles(): Promise<string[]> {
.filter((path) => !/^(?:\.git|\.superpowers|node_modules)\//u.test(path)); .filter((path) => !/^(?:\.git|\.superpowers|node_modules)\//u.test(path));
} }
const findStep = (steps: Mapping[], key: string, value: string): Mapping => { const findStep = (steps: JsonObject[], key: string, value: string): JsonObject => {
const step = steps.find((entry) => entry.get(key) === value); const step = steps.find((entry) => entry[key] === value);
assert(step !== undefined, `${key}: ${value}`); assert(step !== undefined, `${key}: ${value}`);
return step; return step;
}; };
@@ -45,26 +42,16 @@ const findStep = (steps: Mapping[], key: string, value: string): Mapping => {
test("all committed YAML parses", async () => { test("all committed YAML parses", async () => {
const files = await yamlFiles(); const files = await yamlFiles();
assert(files.length > 0); assert(files.length > 0);
await Promise.all( await Promise.all(files.map((file) => yaml(file)));
files.map(async (file) => {
await yaml(file);
}),
);
}); });
test("the action exposes only the master key and scopes it to preparation", async () => { test("the action exposes only the master key and scopes it to preparation", async () => {
const action = await yaml("action.yml"); const action = await yaml("action.yml");
expect([...mapping(action.get("inputs"), "inputs").keys()]).toStrictEqual([ expect(Object.keys(mapping(action["inputs"], "inputs"))).toStrictEqual(["master-key"]);
"master-key", const steps = sequence(mapping(action["runs"], "runs")["steps"], "runs.steps");
]);
const steps = sequence(
mapping(action.get("runs"), "runs").get("steps"),
"runs.steps",
);
for (const step of steps) { for (const step of steps) {
const run = step.get("run"); if (typeof step["run"] === "string") {
if (typeof run === "string") { expect(step["run"].includes("\n"), String(step["name"])).toBe(false);
expect(run.includes("\n"), String(step.get("name"))).toBe(false);
} }
} }
const checkout = findStep(steps, "uses", "actions/checkout@v4"); const checkout = findStep(steps, "uses", "actions/checkout@v4");
@@ -72,24 +59,16 @@ test("the action exposes only the master key and scopes it to preparation", asyn
const agent = findStep(steps, "id", "agent"); const agent = findStep(steps, "id", "agent");
const post = findStep(steps, "id", "post"); const post = findStep(steps, "id", "post");
findStep(steps, "id", "source"); findStep(steps, "id", "source");
expect(mapping(checkout.get("with"), "checkout.with").get("token")).toBe( expect(mapping(checkout["with"], "checkout.with")["token"]).toBe("${{ gitea.token }}");
"${{ gitea.token }}", expect(mapping(prepare["env"], "prepare.env")["BOT_AGENTS_MASTER_KEY"]).toBe(
"${{ inputs.master-key }}",
); );
expect( expect(JSON.stringify(agent).includes("BOT_AGENTS_MASTER_KEY")).toBe(false);
mapping(prepare.get("env"), "prepare.env").get("BOT_AGENTS_MASTER_KEY"), expect(JSON.stringify(post).includes("BOT_AGENTS_MASTER_KEY")).toBe(false);
).toBe("${{ inputs.master-key }}"); expect(mapping(agent["env"], "agent.env")["GITEA_TOKEN"]).toBe("${{ gitea.token }}");
expect( assert(String(post["if"]).includes("always()"));
JSON.stringify(Object.fromEntries(agent)).includes("BOT_AGENTS_MASTER_KEY"),
).toBe(false);
expect(
JSON.stringify(Object.fromEntries(post)).includes("BOT_AGENTS_MASTER_KEY"),
).toBe(false);
expect(mapping(agent.get("env"), "agent.env").get("GITEA_TOKEN")).toBe(
"${{ gitea.token }}",
);
assert(String(post.get("if")).includes("always()"));
for (const step of [prepare, agent, post]) { for (const step of [prepare, agent, post]) {
assert(String(step.get("run")).includes("steps.source.outputs.path")); assert(String(step["run"]).includes("steps.source.outputs.path"));
} }
}); });
@@ -97,19 +76,15 @@ test("the source protection script stages immutable action files", async () => {
const temp = await makeTempDir(); const temp = await makeTempDir();
const outputFile = `${temp}/output`; const outputFile = `${temp}/output`;
try { try {
const environment = inheritedEnvironment(); const result = await runCommand("/bin/bash", ["scripts/protect-source.sh"], {
environment.set("ACTION_PATH", process.cwd()); ...process.env,
environment.set("GITHUB_OUTPUT", outputFile); ACTION_PATH: process.cwd(),
environment.set("RUNNER_TEMP", temp); GITHUB_OUTPUT: outputFile,
const result = await runCommand( RUNNER_TEMP: temp,
"/bin/bash", });
["scripts/protect-source.sh"],
environment,
);
assert(result.success, result.stderr); assert(result.success, result.stderr);
const output = await readFile(outputFile, "utf8"); const path = (await readFile(outputFile, "utf8")).trim().slice(5);
const path = output.trim().slice(5);
const files = [ const files = [
"src/prepare/index.ts", "src/prepare/index.ts",
"src/run/index.ts", "src/run/index.ts",
@@ -120,12 +95,7 @@ test("the source protection script stages immutable action files", async () => {
"profiles.json", "profiles.json",
"prompt.md", "prompt.md",
]; ];
const stats = await Promise.all( const stats = await Promise.all(files.map((file) => stat(`${path}/${file}`)));
files.map(async (file) => {
const info = await stat(`${path}/${file}`);
return info;
}),
);
for (const [index, info] of stats.entries()) { for (const [index, info] of stats.entries()) {
assert(info.isFile(), files[index]); assert(info.isFile(), files[index]);
expect(info.mode & 0o022, files[index]).toStrictEqual(0); expect(info.mode & 0o022, files[index]).toStrictEqual(0);
@@ -138,15 +108,10 @@ test("the source protection script stages immutable action files", async () => {
test("module-relative runtime assets exist", async () => { test("module-relative runtime assets exist", async () => {
const module = new URL("../src/run/index.ts", import.meta.url); const module = new URL("../src/run/index.ts", import.meta.url);
const source = await readFile(module, "utf8"); const source = await readFile(module, "utf8");
const assets = [ const assets = [...source.matchAll(/new URL\("([^"]+)", import\.meta\.url\)/gu)].map(
...source.matchAll(/new URL\("(?<asset>[^"]+)", import\.meta\.url\)/gu), ([, asset = ""]) => new URL(asset, module),
].map(([, asset = ""]) => new URL(asset, module));
const stats = await Promise.all(
assets.map(async (asset) => {
const info = await stat(asset);
return info;
}),
); );
const stats = await Promise.all(assets.map((asset) => stat(asset)));
for (const [index, info] of stats.entries()) { for (const [index, info] of stats.entries()) {
assert(info.isFile(), assets[index]?.pathname); assert(info.isFile(), assets[index]?.pathname);
} }
@@ -154,46 +119,27 @@ test("module-relative runtime assets exist", async () => {
test("the repository uses its trusted main action", async () => { test("the repository uses its trusted main action", async () => {
const workflow = await yaml(".gitea/workflows/agents.yml"); const workflow = await yaml(".gitea/workflows/agents.yml");
const job = mapping( const job = mapping(mapping(workflow["jobs"], "jobs")["agent"], "jobs.agent");
mapping(workflow.get("jobs"), "jobs").get("agent"), const permissions = mapping(job["permissions"], "jobs.agent.permissions");
"jobs.agent", expect(permissions).toStrictEqual({
);
const permissions = mapping(job.get("permissions"), "jobs.agent.permissions");
expect(Object.fromEntries(permissions)).toStrictEqual({
code: "write", code: "write",
issues: "write", issues: "write",
"pull-requests": "write", "pull-requests": "write",
}); });
const steps = sequence(job.get("steps"), "jobs.agent.steps"); const steps = sequence(job["steps"], "jobs.agent.steps");
expect(steps.findIndex((step) => step.get("uses") === "./")).toStrictEqual( expect(steps.findIndex((step) => step["uses"] === "./")).toStrictEqual(-1);
-1, const trusted = findStep(steps, "uses", "https://git.capsulizers.com/commons/bot-agents@main");
); expect(mapping(trusted["with"], "trusted.with")["master-key"]).toBe(
const trusted = findStep(
steps,
"uses",
"https://git.capsulizers.com/commons/bot-agents@main",
);
expect(mapping(trusted.get("with"), "trusted.with").get("master-key")).toBe(
"${{ secrets.BOT_AGENTS_MASTER_KEY }}", "${{ secrets.BOT_AGENTS_MASTER_KEY }}",
); );
expect( expect(JSON.stringify(workflow).includes("gitea.actor != 'bot'")).toBe(true);
JSON.stringify(Object.fromEntries(workflow)).includes(
"gitea.actor != 'bot'",
),
).toBe(true);
}); });
test("CI checks every phase and the root isolation suite", async () => { test("CI checks every phase and the root isolation suite", async () => {
const workflow = await yaml(".gitea/workflows/check.yml"); const workflow = await yaml(".gitea/workflows/check.yml");
const job = mapping( const job = mapping(mapping(workflow["jobs"], "jobs")["check"], "jobs.check");
mapping(workflow.get("jobs"), "jobs").get("check"), const commands = sequence(job["steps"], "jobs.check.steps")
"jobs.check", .map((step) => (typeof step["run"] === "string" ? step["run"] : ""))
);
const commands = sequence(job.get("steps"), "jobs.check.steps")
.map((step) => {
const run = step.get("run");
return typeof run === "string" ? run : "";
})
.join("\n"); .join("\n");
// `vp check` type-checks every phase, and `vp test` runs each of them under // `vp check` type-checks every phase, and `vp test` runs each of them under
// Node as well as the root-only isolation tests. // Node as well as the root-only isolation tests.
@@ -207,8 +153,7 @@ test("uses the standard Skills installer without custom discovery", async () =>
assert(runner.includes("skills add obra/superpowers")); assert(runner.includes("skills add obra/superpowers"));
const removed = await stat("superpowers.ts").then( const removed = await stat("superpowers.ts").then(
() => false, () => false,
(error: unknown) => (error: unknown) => error instanceof Error && "code" in error && error.code === "ENOENT",
error instanceof Error && "code" in error && error.code === "ENOENT",
); );
assert(removed, "superpowers.ts should be removed"); assert(removed, "superpowers.ts should be removed");
}); });
@@ -229,19 +174,10 @@ test("profile preparation does not receive provider credentials", async () => {
expect(runner.includes("prepareProfile(profile, token)")).toBe(false); expect(runner.includes("prepareProfile(profile, token)")).toBe(false);
}); });
test("central profiles fall back from Claude to Codex to OpenCode", async () => { test("central profiles fall back from Codex to Claude to OpenCode", async () => {
const credentials: unknown = JSON.parse( const credentials: unknown = JSON.parse(await readFile("profiles.json", "utf8"));
await readFile("profiles.json", "utf8"), const profiles = sequence(mapping(credentials, "profiles.json")["profiles"], "profiles");
); expect(profiles.map((profile) => profile["type"])).toStrictEqual(["codex", "claude", "opencode"]);
const profiles = sequence( expect(profiles[2]?.["model"]).toBe("openrouter/qwen/qwen3.8-27b");
mapping(credentials, "profiles.json").get("profiles"), assert(String(profiles[2]?.["token"]).startsWith("v1:"));
"profiles",
);
expect(profiles.map((profile) => profile.get("type"))).toStrictEqual([
"CLAUDE",
"CODEX",
"OPENCODE",
]);
expect(profiles[2]?.get("model")).toBe("openrouter/qwen/qwen3.8-27b");
assert(String(profiles[2]?.get("token")).startsWith("v1:"));
}); });
+5 -17
View File
@@ -2,14 +2,9 @@ import explicitTypes from "eslint-plugin-explicit-types";
import importStructure from "eslint-plugin-import-structure"; import importStructure from "eslint-plugin-import-structure";
import { defineConfig } from "vite-plus"; import { defineConfig } from "vite-plus";
import projectLint, { projectOverrides } from "./scripts/project-lint.ts"; import projectLint from "./scripts/project-lint.ts";
export default defineConfig({ export default defineConfig({
fmt: {
printWidth: 80,
quoteProps: "preserve",
embeddedLanguageFormatting: "off",
},
lint: { lint: {
plugins: ["typescript", "unicorn", "oxc", "import"], plugins: ["typescript", "unicorn", "oxc", "import"],
jsPlugins: [ jsPlugins: [
@@ -17,20 +12,13 @@ export default defineConfig({
"eslint-plugin-import-structure", "eslint-plugin-import-structure",
"./scripts/project-lint.ts", "./scripts/project-lint.ts",
], ],
categories: { categories: { correctness: "error", suspicious: "error", pedantic: "error", perf: "error" },
correctness: "error",
suspicious: "error",
pedantic: "error",
perf: "error",
style: "error",
restriction: "error",
},
rules: { rules: {
...explicitTypes.configs.all.rules, ...explicitTypes.configs.concrete.rules,
...importStructure.configs.all.rules, ...explicitTypes.configs.absence.rules,
...importStructure.configs.modules.rules,
...projectLint.configs.project.rules, ...projectLint.configs.project.rules,
}, },
overrides: projectOverrides,
options: { options: {
typeAware: true, typeAware: true,
typeCheck: true, typeCheck: true,