@ygrishajev/jig 0.0.0-stage → 1.0.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (117) hide show
  1. package/LICENSE +21 -0
  2. package/README.md +135 -2
  3. package/dist/adapters/find-symlink.js +23 -0
  4. package/dist/adapters/git/git-workspace.js +297 -0
  5. package/dist/adapters/local-store/credentials-file.js +51 -0
  6. package/dist/adapters/local-store/local-run-store.js +45 -0
  7. package/dist/adapters/local-store/local-state.js +12 -0
  8. package/dist/adapters/local-store/metrics-log.js +119 -0
  9. package/dist/adapters/local-store/run-artefacts.js +76 -0
  10. package/dist/adapters/local-store/run-lock.js +51 -0
  11. package/dist/adapters/local-store/run-paths.js +49 -0
  12. package/dist/adapters/logging/create-logger.js +29 -0
  13. package/dist/adapters/run-store/composite-run-store.js +57 -0
  14. package/dist/adapters/run-store/git-remote-run-store.js +239 -0
  15. package/dist/adapters/sandbox-image/docker-images.js +93 -0
  16. package/dist/adapters/sandbox-image/image-recipe.js +96 -0
  17. package/dist/adapters/sandbox-image/latest-agent-versions.js +9 -0
  18. package/dist/adapters/sandcastle/agents.js +100 -0
  19. package/dist/adapters/sandcastle/codex-auth.js +191 -0
  20. package/dist/adapters/sandcastle/git-hooks.js +20 -0
  21. package/dist/adapters/sandcastle/open-session.js +67 -0
  22. package/dist/adapters/sandcastle/private-clone-docker.js +232 -0
  23. package/dist/adapters/sandcastle/sandcastle-env.js +17 -0
  24. package/dist/adapters/sandcastle/sandcastle-session.js +338 -0
  25. package/dist/adapters/sandcastle/structured-output.js +35 -0
  26. package/dist/adapters/sandcastle/usage.js +65 -0
  27. package/dist/adapters/telemetry/open-telemetry.js +29 -0
  28. package/dist/adapters/terminal/ask-for-agents.js +61 -0
  29. package/dist/adapters/terminal/ask-for-credential.js +32 -0
  30. package/dist/adapters/terminal/ask-for-preset.js +15 -0
  31. package/dist/adapters/terminal/standard-input.js +7 -0
  32. package/dist/adapters/terminal/terminal.js +45 -0
  33. package/dist/app/container.js +131 -0
  34. package/dist/app/init-sandbox.js +185 -0
  35. package/dist/app/observed-events.js +10 -0
  36. package/dist/app/report-cleanup.js +10 -0
  37. package/dist/app/run-jig.js +101 -0
  38. package/dist/app/run-status.js +20 -0
  39. package/dist/app/run-stores.js +107 -0
  40. package/dist/app/sandbox-image.js +151 -0
  41. package/dist/app/throwaway-sandbox.js +49 -0
  42. package/dist/cli/app-action.js +18 -0
  43. package/dist/cli/commands/presets.js +32 -0
  44. package/dist/cli/commands/run.js +82 -0
  45. package/dist/cli/commands/sandbox.js +54 -0
  46. package/dist/cli/commands/status.js +41 -0
  47. package/dist/cli/config-option.js +18 -0
  48. package/dist/cli/exit-when-done.js +11 -0
  49. package/dist/cli/log-format-option.js +14 -0
  50. package/dist/cli/main.js +33 -0
  51. package/dist/cli/read-request.js +36 -0
  52. package/dist/cli/with-app.js +73 -0
  53. package/dist/cli/with-error-handling.js +31 -0
  54. package/dist/cli/with-input.js +27 -0
  55. package/dist/config/describe-issues.js +6 -0
  56. package/dist/config/environment.js +53 -0
  57. package/dist/config/load-config.js +122 -0
  58. package/dist/config/presets.js +150 -0
  59. package/dist/config/write-config.js +39 -0
  60. package/dist/domain/agent-role.js +12 -0
  61. package/dist/domain/apply-outcome.js +132 -0
  62. package/dist/domain/completion-reuse.js +176 -0
  63. package/dist/domain/design-docs.js +3 -0
  64. package/dist/domain/design-review-report.js +86 -0
  65. package/dist/domain/design-review.js +193 -0
  66. package/dist/domain/errors.js +139 -0
  67. package/dist/domain/events.js +8 -0
  68. package/dist/domain/final-check.js +133 -0
  69. package/dist/domain/outcome.js +26 -0
  70. package/dist/domain/plan-coverage.js +129 -0
  71. package/dist/domain/protected-paths.js +35 -0
  72. package/dist/domain/retry.js +21 -0
  73. package/dist/domain/run-id.js +42 -0
  74. package/dist/domain/run-state.js +147 -0
  75. package/dist/domain/settings.js +49 -0
  76. package/dist/domain/slice.js +63 -0
  77. package/dist/domain/usage.js +1 -0
  78. package/dist/domain/work-facts.js +22 -0
  79. package/dist/flow/define-flow.js +11 -0
  80. package/dist/flow/engine.js +255 -0
  81. package/dist/flow/run-flow.js +129 -0
  82. package/dist/git/branch.js +26 -0
  83. package/dist/git/merge.js +92 -0
  84. package/dist/git/repository.js +48 -0
  85. package/dist/git/throwaway-branch.js +64 -0
  86. package/dist/observers/logging-observer.js +51 -0
  87. package/dist/observers/metrics.js +109 -0
  88. package/dist/observers/run-events.js +25 -0
  89. package/dist/observers/tracing-observer.js +86 -0
  90. package/dist/ports/agent-session.js +1 -0
  91. package/dist/ports/observability.js +1 -0
  92. package/dist/ports/run-store.js +1 -0
  93. package/dist/ports/sandbox-git.js +1 -0
  94. package/dist/ports/sandbox-images.js +1 -0
  95. package/dist/ports/workspace.js +1 -0
  96. package/dist/prompts/design-review.js +172 -0
  97. package/dist/prompts/final-check.js +58 -0
  98. package/dist/prompts/planning.js +111 -0
  99. package/dist/prompts/pull-request.js +78 -0
  100. package/dist/prompts/slice.js +254 -0
  101. package/dist/prompts/toolchain.js +37 -0
  102. package/dist/steps/completion-reuse.js +32 -0
  103. package/dist/steps/design-review.js +38 -0
  104. package/dist/steps/final-check.js +39 -0
  105. package/dist/steps/finishing.js +72 -0
  106. package/dist/steps/planning.js +77 -0
  107. package/dist/steps/pull-request-description.js +142 -0
  108. package/dist/steps/slice.js +149 -0
  109. package/package.json +95 -4
  110. package/presets/cheap-volume.json +7 -0
  111. package/presets/claude-only.json +7 -0
  112. package/presets/codex-only.json +7 -0
  113. package/presets/codex-reviewed-opencode.json +7 -0
  114. package/presets/full-power-codex.json +7 -0
  115. package/presets/full-power.json +7 -0
  116. package/presets/long-claude.json +7 -0
  117. package/presets/open-weight.json +7 -0
@@ -0,0 +1,29 @@
1
+ /**
2
+ * Starts the OpenTelemetry SDK with an OTLP/HTTP trace exporter, or nothing when telemetry is
3
+ * off. Loaded lazily so a run without telemetry never pays for it.
4
+ */
5
+ export async function startTelemetry(telemetry) {
6
+ if (!telemetry)
7
+ return undefined;
8
+ const [{ NodeSDK }, { OTLPTraceExporter }, api] = await Promise.all([
9
+ import('@opentelemetry/sdk-node'),
10
+ import('@opentelemetry/exporter-trace-otlp-http'),
11
+ import('@opentelemetry/api'),
12
+ ]);
13
+ const sdk = new NodeSDK({
14
+ serviceName: telemetry.serviceName,
15
+ traceExporter: new OTLPTraceExporter(),
16
+ instrumentations: [],
17
+ });
18
+ sdk.start();
19
+ return { tracer: api.trace.getTracer('jig'), shutdown: () => sdk.shutdown() };
20
+ }
21
+ /**
22
+ * The `OTEL_*` variables passed into the sandbox, plus the switch that makes Claude Code export
23
+ * its own telemetry to the same collector.
24
+ */
25
+ export function sandboxTelemetryEnvironment(telemetry) {
26
+ if (!telemetry)
27
+ return {};
28
+ return { ...telemetry.forwarded, CLAUDE_CODE_ENABLE_TELEMETRY: '1' };
29
+ }
@@ -0,0 +1,61 @@
1
+ import { checkbox, input, select } from '@inquirer/prompts';
2
+ import { AGENTS, modelProblem } from '../sandcastle/agents.js';
3
+ import { askInTerminal, PROCESS_TERMINAL } from './terminal.js';
4
+ /** The agent the operator picks for each role; `undefined` when nobody can answer or they cancel. */
5
+ export function askForAgents(roles, terminal = PROCESS_TERMINAL) {
6
+ return askInTerminal(terminal, (open) => ask(roles, open));
7
+ }
8
+ async function ask(roles, terminal) {
9
+ const agents = await chooseAgents(terminal);
10
+ const assigned = {};
11
+ for (const role of roles) {
12
+ assigned[role] = agents.length === 1 ? agents[0] : await pickForRole(role, agents, terminal);
13
+ }
14
+ return assigned;
15
+ }
16
+ async function chooseAgents(terminal) {
17
+ const providers = await checkbox({
18
+ message: 'Which agents?',
19
+ choices: Object.keys(AGENTS).map((value) => ({ value })),
20
+ required: true,
21
+ }, terminal);
22
+ const agents = [];
23
+ for (const provider of providers) {
24
+ const models = await chooseModels(provider, terminal);
25
+ agents.push(...models.map((model) => ({ provider, model })));
26
+ }
27
+ return agents;
28
+ }
29
+ async function chooseModels(provider, terminal) {
30
+ const options = AGENTS[provider].modelOptions;
31
+ if (options.length === 0)
32
+ return [await typeModel(provider, terminal)];
33
+ const picked = await checkbox({
34
+ message: `Which ${provider} models?`,
35
+ choices: [
36
+ ...options.map((value) => ({ value })),
37
+ { name: 'Other (type a name)', value: undefined },
38
+ ],
39
+ required: true,
40
+ }, terminal);
41
+ const models = picked.filter((model) => model !== undefined);
42
+ if (picked.includes(undefined))
43
+ models.push(await typeModel(provider, terminal));
44
+ return [...new Set(models)];
45
+ }
46
+ async function typeModel(provider, terminal) {
47
+ const typed = await input({
48
+ message: `Which ${provider} model?`,
49
+ validate: (model) => model.trim() ? (modelProblem(provider, model.trim()) ?? true) : 'Type a model name.',
50
+ }, terminal);
51
+ return typed.trim();
52
+ }
53
+ function pickForRole(role, agents, terminal) {
54
+ return select({
55
+ message: `Which model for the ${role} step?`,
56
+ choices: agents.map((value) => ({ name: labelOf(value), value })),
57
+ }, terminal);
58
+ }
59
+ function labelOf({ provider, model }) {
60
+ return `${provider} / ${model}`;
61
+ }
@@ -0,0 +1,32 @@
1
+ import { confirm, input, password, select } from '@inquirer/prompts';
2
+ import { CREDENTIALS_FILE } from '../local-store/credentials-file.js';
3
+ import { AGENTS } from '../sandcastle/agents.js';
4
+ import { askInTerminal, PROCESS_TERMINAL } from './terminal.js';
5
+ /** A credential typed by the operator, who decides whether it is kept for later runs. */
6
+ export function askForCredential(missing, terminal = PROCESS_TERMINAL) {
7
+ return askInTerminal(terminal, (open) => ask(missing, open));
8
+ }
9
+ async function ask({ provider, keys }, terminal) {
10
+ const { credentialHelp, credentialIsSecret } = AGENTS[provider];
11
+ const message = `${provider} needs a credential (${credentialHelp})`;
12
+ const name = keys.length === 1
13
+ ? keys[0]
14
+ : await select({ message, choices: keys.map((value) => ({ value })) }, terminal);
15
+ const prompt = {
16
+ message: keys.length === 1 ? `${message} — ${name}:` : `${name}:`,
17
+ validate: (value) => unsavableProblem(value) ?? AGENTS[provider].credentialProblem(value.trim()) ?? true,
18
+ };
19
+ const value = await (credentialIsSecret
20
+ ? password({ ...prompt, mask: true }, terminal)
21
+ : input(prompt, terminal));
22
+ const save = await confirm({
23
+ message: `Save it to ${CREDENTIALS_FILE} for later runs? It is ignored by git and only you can read it. Otherwise it lasts for this command only.`,
24
+ default: true,
25
+ }, terminal);
26
+ return { name, value: value.trim(), save };
27
+ }
28
+ function unsavableProblem(value) {
29
+ if (!value.trim())
30
+ return 'Enter a value.';
31
+ return /["\\\r\n]/.test(value) ? 'A credential cannot hold a quote or a backslash.' : undefined;
32
+ }
@@ -0,0 +1,15 @@
1
+ import { select } from '@inquirer/prompts';
2
+ import { askInTerminal, PROCESS_TERMINAL } from './terminal.js';
3
+ export function askForPreset(presets, terminal = PROCESS_TERMINAL) {
4
+ return askInTerminal(terminal, (open) => select({
5
+ message: 'Which preset?',
6
+ choices: [
7
+ { name: 'jig.config.json (no preset)', value: { kind: 'none' } },
8
+ ...presets.map(choiceFor),
9
+ ],
10
+ }, open));
11
+ }
12
+ function choiceFor({ name, source, description }) {
13
+ const label = source === 'builtin' ? name : `${name} (${source})`;
14
+ return { name: label, value: { kind: 'preset', name }, description };
15
+ }
@@ -0,0 +1,7 @@
1
+ import { text } from 'node:stream/consumers';
2
+ export function processStandardInput() {
3
+ return {
4
+ isTerminal: process.stdin.isTTY === true,
5
+ readAll: () => text(process.stdin),
6
+ };
7
+ }
@@ -0,0 +1,45 @@
1
+ import { panic } from 'better-result';
2
+ import { open } from 'node:fs/promises';
3
+ import { ReadStream } from 'node:tty';
4
+ import { messageOf } from '../../domain/errors.js';
5
+ export const PROCESS_TERMINAL = {
6
+ input: process.stdin,
7
+ output: process.stdout,
8
+ allowControllingInput: true,
9
+ };
10
+ /** What the operator answers; `undefined` when nobody can answer or they cancel. */
11
+ export async function askInTerminal(terminal, ask, openTerminal = openControllingTerminal) {
12
+ if (!terminal.output.isTTY)
13
+ return undefined;
14
+ const controlling = terminal.input.isTTY
15
+ ? undefined
16
+ : terminal.allowControllingInput
17
+ ? await openTerminal()
18
+ : undefined;
19
+ const interactive = terminal.input.isTTY ? terminal : controlling?.terminal;
20
+ if (!interactive)
21
+ return undefined;
22
+ try {
23
+ return await ask(interactive).catch((error) => {
24
+ if (error instanceof Error && error.name === 'ExitPromptError')
25
+ return undefined;
26
+ panic(messageOf(error), error);
27
+ });
28
+ }
29
+ finally {
30
+ await controlling?.close();
31
+ }
32
+ }
33
+ async function openControllingTerminal() {
34
+ const handle = await open('/dev/tty', 'r').catch(() => undefined);
35
+ if (!handle)
36
+ return undefined;
37
+ const input = new ReadStream(handle.fd);
38
+ return {
39
+ terminal: { input, output: process.stdout },
40
+ close: async () => {
41
+ input.destroy();
42
+ await handle.close();
43
+ },
44
+ };
45
+ }
@@ -0,0 +1,131 @@
1
+ import { asFunction, asValue, createContainer, InjectionMode } from 'awilix';
2
+ import { Result } from 'better-result';
3
+ import { GitWorkspace } from '../adapters/git/git-workspace.js';
4
+ import { MetricsLog } from '../adapters/local-store/metrics-log.js';
5
+ import { RunArtefacts } from '../adapters/local-store/run-artefacts.js';
6
+ import { runLogFile } from '../adapters/local-store/run-paths.js';
7
+ import { createConsoleLogger, createRunLogger, } from '../adapters/logging/create-logger.js';
8
+ import { DockerImages } from '../adapters/sandbox-image/docker-images.js';
9
+ import { latestAgentVersions } from '../adapters/sandbox-image/latest-agent-versions.js';
10
+ import { openSandcastleSession, } from '../adapters/sandcastle/open-session.js';
11
+ import { askForAgents } from '../adapters/terminal/ask-for-agents.js';
12
+ import { askForCredential, } from '../adapters/terminal/ask-for-credential.js';
13
+ import { runSettingsFrom } from '../config/load-config.js';
14
+ import { retryResult, transientRetryPolicy } from '../domain/retry.js';
15
+ import { LoggingObserver } from '../observers/logging-observer.js';
16
+ import { MetricsObserver } from '../observers/metrics.js';
17
+ import { TracingObserver } from '../observers/tracing-observer.js';
18
+ import { observedEvents } from './observed-events.js';
19
+ import { reportCleanup } from './report-cleanup.js';
20
+ import { sandboxImageName } from './sandbox-image.js';
21
+ export function createAppContainer(input) {
22
+ const container = createContainer({
23
+ injectionMode: InjectionMode.PROXY,
24
+ strict: true,
25
+ });
26
+ container.register({
27
+ repoRoot: asValue(input.repoRoot),
28
+ environment: asValue(input.environment),
29
+ logFormat: asValue(input.logFormat),
30
+ logLevel: asValue(input.logLevel ?? 'info'),
31
+ configFile: asValue(input.configFile),
32
+ config: asValue(input.config),
33
+ settings: asFunction(({ config }) => runSettingsFrom(config)).singleton(),
34
+ logger: asFunction(({ logFormat, logLevel }) => createConsoleLogger(logFormat, logLevel)).singleton(),
35
+ clock: asValue({ now: () => Date.now() }),
36
+ artefacts: asFunction(({ repoRoot }) => new RunArtefacts(repoRoot)).singleton(),
37
+ images: asFunction(({ logger, environment }) => new DockerImages({
38
+ cache: environment.imageCache,
39
+ onOutput: (line) => logger.debug(line.trimEnd()),
40
+ })).singleton(),
41
+ latestVersions: asValue(latestAgentVersions),
42
+ askForAgents: asValue((roles) => askForAgents(roles)),
43
+ askForCredential: asValue((missing) => askForCredential(missing)),
44
+ openSession: asFunction(({ repoRoot, config, environment, logger }) => (input) => openSandcastleSession({
45
+ repoRoot,
46
+ config,
47
+ environment,
48
+ logger,
49
+ imageName: sandboxImageName(repoRoot, config),
50
+ }, input)).singleton(),
51
+ });
52
+ return container;
53
+ }
54
+ /**
55
+ * Starts the run's sandbox, builds everything scoped to the run and hands `use` what the engine
56
+ * needs. The sandbox is closed and the scope disposed afterwards, however `use` ends.
57
+ */
58
+ export async function withRunScope(app, { runId, baseBranch }, runStore, options, use) {
59
+ const scope = await openRunScope(app, { runId, baseBranch }, runStore, options);
60
+ if (scope.isErr())
61
+ return Result.err(scope.error);
62
+ let used;
63
+ let closed;
64
+ try {
65
+ used = await use(scope.value.cradle.engineDependencies);
66
+ }
67
+ finally {
68
+ closed = await closeRunScope(scope.value);
69
+ }
70
+ return reportCleanup(used, closed, app.cradle.logger);
71
+ }
72
+ async function openRunScope(app, run, runStore, options) {
73
+ const { repoRoot } = app.cradle;
74
+ const scope = app.createScope();
75
+ scope.register({
76
+ run: asValue(run),
77
+ runStore: asValue(runStore),
78
+ runLogger: asFunction(({ logFormat, logLevel }) => createRunLogger(logFormat, runLogFile(repoRoot, run.runId), logLevel).child({
79
+ runId: run.runId,
80
+ })).scoped(),
81
+ metricsLog: asFunction(() => new MetricsLog(repoRoot, run.runId)).scoped(),
82
+ events: asFunction(({ runLogger, metricsLog, clock }) => observedEvents(runLogger, [
83
+ new LoggingObserver(runLogger),
84
+ new MetricsObserver((record) => metricsLog.append(record), clock),
85
+ ...(options.tracer ? [new TracingObserver(options.tracer)] : []),
86
+ ])).scoped(),
87
+ });
88
+ const opened = await openSessionRetrying(scope.cradle);
89
+ if (opened.isErr()) {
90
+ await scope.dispose();
91
+ return Result.err(opened.error);
92
+ }
93
+ const session = opened.value;
94
+ scope.register({
95
+ session: asValue(session),
96
+ workspace: asFunction(() => new GitWorkspace({
97
+ repoRoot,
98
+ worktreePath: session.worktreePath,
99
+ sandbox: session,
100
+ signing: app.cradle.config.commitSigning,
101
+ ...run,
102
+ })).scoped(),
103
+ engineDependencies: asFunction(({ workspace, runStore: store, events, clock, settings }) => ({
104
+ ports: { agent: session, workspace },
105
+ store,
106
+ events,
107
+ clock,
108
+ settings,
109
+ })).scoped(),
110
+ });
111
+ return Result.ok(scope);
112
+ }
113
+ /**
114
+ * A sandbox that failed to start for a reason that may pass — Docker, the network under the
115
+ * setup command — gets the same bounded retries as a step; a configuration problem does not.
116
+ */
117
+ function openSessionRetrying({ openSession, run, events, settings, runLogger, }) {
118
+ return retryResult(() => openSession({ run, events }), {
119
+ ...transientRetryPolicy(settings),
120
+ onFailedAttempt: ({ error, attempt }) => runLogger.warn({ err: error, attempt }, 'the sandbox did not start'),
121
+ });
122
+ }
123
+ /** Awilix's `dispose` alone would leave the sandbox running, so the session is closed first. */
124
+ async function closeRunScope(scope) {
125
+ try {
126
+ return await scope.cradle.session.close();
127
+ }
128
+ finally {
129
+ await scope.dispose();
130
+ }
131
+ }
@@ -0,0 +1,185 @@
1
+ import { asValue } from 'awilix';
2
+ import { Result } from 'better-result';
3
+ import { existsSync } from 'node:fs';
4
+ import { writeFile } from 'node:fs/promises';
5
+ import path from 'node:path';
6
+ import { z } from 'zod';
7
+ import { refuseSymlinks } from '../adapters/find-symlink.js';
8
+ import { saveCredential } from '../adapters/local-store/credentials-file.js';
9
+ import { BASE_DOCKERFILE, DOCKERFILE, SANDBOX_DIRECTORY, withToolchain, } from '../adapters/sandbox-image/image-recipe.js';
10
+ import { collectCredentials, missingCredentials } from '../adapters/sandcastle/agents.js';
11
+ import { ignoreSandcastleDirectory, } from '../adapters/sandcastle/sandcastle-session.js';
12
+ import { withCredentials } from '../config/environment.js';
13
+ import { configuredSteps, loadConfig, stepsWithoutAgent, } from '../config/load-config.js';
14
+ import { updateConfigFile } from '../config/write-config.js';
15
+ import { ConfigInvalid, messageOf, SetupCommandFailed, } from '../domain/errors.js';
16
+ import { toolchainPrompt } from '../prompts/toolchain.js';
17
+ import { ensureSandboxImage, readSandboxDockerfile } from './sandbox-image.js';
18
+ import { withThrowawaySandbox } from './throwaway-sandbox.js';
19
+ /**
20
+ * Writes the sandbox Dockerfile and a starter config if the repository has none, and asks which
21
+ * agents to use for steps without one; with none chosen, it stops there and says what to set. It then
22
+ * asks for credentials those agents lack. With an agent, the planner then fills in the project's toolchain and setup and verify commands, and the
23
+ * result counts only once both commands pass inside the built sandbox — a failure goes back to
24
+ * the planner. Without an agent, the commands already configured are checked.
25
+ */
26
+ export function initSandbox(app, options) {
27
+ return Result.gen(async function* () {
28
+ const { repoRoot, configFile } = app.cradle;
29
+ yield* Result.await(writeStarterFiles(repoRoot, configFile));
30
+ if (options.useAgent)
31
+ yield* Result.await(chooseMissingAgents(app));
32
+ const config = yield* loadConfig(configFile);
33
+ app.register({ config: asValue(config) });
34
+ const steps = configuredSteps(config);
35
+ if (steps.isErr()) {
36
+ return Result.ok({
37
+ status: 'needs-agents',
38
+ instruction: steps.error.message,
39
+ });
40
+ }
41
+ if (!options.useAgent)
42
+ return checkConfiguredCommands(app, config, Object.values(steps.value));
43
+ yield* Result.await(ensureCredentials(app, Object.values(steps.value)));
44
+ let previousFailure;
45
+ for (let attempt = 1; attempt <= TOOLCHAIN_ATTEMPTS; attempt++) {
46
+ const proposal = yield* Result.await(proposeToolchain(app, previousFailure));
47
+ yield* Result.await(writeToolchain(repoRoot, proposal.toolchain));
48
+ yield* Result.await(updateConfigFile(configFile, {
49
+ setupCommand: proposal.setupCommand,
50
+ verifyCommand: proposal.verifyCommand,
51
+ }));
52
+ previousFailure = yield* Result.await(checkInSandbox(app, proposal.setupCommand, proposal.verifyCommand));
53
+ if (!previousFailure)
54
+ return Result.ok({ status: 'verified', attempts: attempt });
55
+ app.cradle.logger.warn(`attempt ${attempt} did not pass in the sandbox`);
56
+ }
57
+ return Result.ok({
58
+ status: 'failed',
59
+ attempts: TOOLCHAIN_ATTEMPTS,
60
+ failure: previousFailure ?? '',
61
+ });
62
+ });
63
+ }
64
+ async function writeStarterFiles(repoRoot, configFile) {
65
+ const ignored = await ignoreSandcastleDirectory(repoRoot);
66
+ if (ignored.isErr())
67
+ return ignored;
68
+ const dockerfile = path.join(repoRoot, SANDBOX_DIRECTORY, DOCKERFILE);
69
+ const config = configFile.path;
70
+ const refused = refuseSymlinks([dockerfile, config]);
71
+ if (refused.isErr())
72
+ return refused;
73
+ const written = await writeIfMissing(dockerfile, BASE_DOCKERFILE);
74
+ if (written.isErr())
75
+ return written;
76
+ return writeIfMissing(config, '{}\n');
77
+ }
78
+ function writeIfMissing(file, contents) {
79
+ return existsSync(file) ? Promise.resolve(Result.ok()) : writeRepoFile(file, contents);
80
+ }
81
+ function writeRepoFile(file, contents) {
82
+ return Result.tryPromise({
83
+ try: () => writeFile(file, contents),
84
+ catch: (cause) => new ConfigInvalid({ message: `Could not write ${file}: ${messageOf(cause)}` }),
85
+ });
86
+ }
87
+ async function chooseMissingAgents(app) {
88
+ const { configFile, askForAgents } = app.cradle;
89
+ const config = loadConfig(configFile);
90
+ if (config.isErr())
91
+ return Result.err(config.error);
92
+ const missing = stepsWithoutAgent(config.value);
93
+ if (missing.length === 0)
94
+ return Result.ok();
95
+ const agents = await askForAgents(missing);
96
+ return agents ? updateConfigFile(configFile, agents) : Result.ok();
97
+ }
98
+ async function checkConfiguredCommands(app, config, steps) {
99
+ const { verifyCommand, setupCommand } = config;
100
+ if (!verifyCommand)
101
+ return Result.ok({ status: 'written' });
102
+ const credentials = await ensureCredentials(app, steps);
103
+ if (credentials.isErr())
104
+ return Result.err(credentials.error);
105
+ const checked = await checkInSandbox(app, setupCommand, verifyCommand);
106
+ return checked.map((failure) => failure ? { status: 'failed', attempts: 1, failure } : { status: 'verified', attempts: 1 });
107
+ }
108
+ /**
109
+ * Asks for the credentials the configured agents lack, before anything is built for them. The
110
+ * operator decides whether each is saved; either way it lasts for the rest of this command.
111
+ */
112
+ async function ensureCredentials(app, steps) {
113
+ return Result.gen(async function* () {
114
+ const { repoRoot, environment, askForCredential } = app.cradle;
115
+ const entered = {};
116
+ for (const missing of yield* missingCredentials(steps, environment.credential)) {
117
+ const credential = await askForCredential(missing);
118
+ if (!credential)
119
+ break;
120
+ entered[credential.name] = credential.value;
121
+ if (credential.save) {
122
+ yield* Result.await(saveCredential(repoRoot, credential.name, credential.value));
123
+ }
124
+ }
125
+ const completed = withCredentials(environment, entered);
126
+ app.register({ environment: asValue(completed) });
127
+ yield* collectCredentials(steps, completed.credential);
128
+ return Result.ok();
129
+ });
130
+ }
131
+ /**
132
+ * Rebuilds the image and runs both commands in a fresh sandbox; returns how either command
133
+ * failed, if one did. Anything else — Docker, credentials — is not the toolchain's fault and is
134
+ * returned as the error, rather than spending the planner's attempts on it.
135
+ */
136
+ async function checkInSandbox(app, setupCommand, verifyCommand) {
137
+ const checked = await withSandbox(app, setupCommand ?? null, async (session) => {
138
+ const verify = await session.exec(verifyCommand);
139
+ return verify.map(({ exitCode, output }) => exitCode === 0
140
+ ? undefined
141
+ : `verifyCommand "${verifyCommand}" exited with ${exitCode}:\n${output.slice(-3000)}`);
142
+ });
143
+ if (checked.isErr() && checked.error instanceof SetupCommandFailed) {
144
+ return Result.ok(checked.error.message);
145
+ }
146
+ return checked;
147
+ }
148
+ async function withSandbox(app, setupCommand, use) {
149
+ const image = await ensureSandboxImage(app.cradle);
150
+ if (image.isErr())
151
+ return Result.err(image.error);
152
+ return withThrowawaySandbox(app, setupCommand, use);
153
+ }
154
+ /** How many times the planner gets to fix a toolchain that failed setup or verify. */
155
+ const TOOLCHAIN_ATTEMPTS = 3;
156
+ async function proposeToolchain(app, previousFailure) {
157
+ return Result.gen(async function* () {
158
+ const { repoRoot, configFile } = app.cradle;
159
+ const config = yield* loadConfig(configFile);
160
+ const dockerfile = yield* Result.await(readSandboxDockerfile(repoRoot));
161
+ const proposed = yield* Result.await(withSandbox(app, null, (session) => session.runForOutput({
162
+ role: 'planner',
163
+ prompt: toolchainPrompt({
164
+ dockerfile,
165
+ setupCommand: config.setupCommand,
166
+ verifyCommand: config.verifyCommand,
167
+ previousFailure,
168
+ }),
169
+ schema: toolchainSchema,
170
+ })));
171
+ return Result.ok(proposed);
172
+ });
173
+ }
174
+ const toolchainSchema = z.object({
175
+ toolchain: z.string(),
176
+ setupCommand: z.string(),
177
+ verifyCommand: z.string(),
178
+ });
179
+ async function writeToolchain(repoRoot, toolchain) {
180
+ const dockerfile = await readSandboxDockerfile(repoRoot);
181
+ const filled = dockerfile.andThen((contents) => withToolchain(contents, toolchain));
182
+ if (filled.isErr())
183
+ return Result.err(filled.error);
184
+ return writeRepoFile(path.join(repoRoot, SANDBOX_DIRECTORY, DOCKERFILE), filled.value);
185
+ }
@@ -0,0 +1,10 @@
1
+ import { observe, RunEvents } from '../observers/run-events.js';
2
+ /** Events the given observers hear; one that fails is logged, and the others still hear the event. */
3
+ export function observedEvents(logger, observers) {
4
+ const events = new RunEvents();
5
+ const onObserverError = (error) => logger.warn({ err: error }, 'an observer failed');
6
+ for (const observer of observers) {
7
+ observe(events, (event) => observer.handle(event), onObserverError);
8
+ }
9
+ return events;
10
+ }
@@ -0,0 +1,10 @@
1
+ import { Result } from 'better-result';
2
+ /** A failed cleanup is the outcome only when the work itself succeeded; otherwise it is logged. */
3
+ export function reportCleanup(used, cleanup, logger) {
4
+ if (cleanup.isOk())
5
+ return used;
6
+ if (used.isOk())
7
+ return Result.err(cleanup.error);
8
+ logger.warn({ err: cleanup.error }, 'cleanup failed after the run failed');
9
+ return used;
10
+ }
@@ -0,0 +1,101 @@
1
+ import { Result } from 'better-result';
2
+ import { MetricsLog } from '../adapters/local-store/metrics-log.js';
3
+ import { lockRun } from '../adapters/local-store/run-lock.js';
4
+ import { stepCredentials } from '../adapters/sandcastle/open-session.js';
5
+ import { startTelemetry } from '../adapters/telemetry/open-telemetry.js';
6
+ import { validationWarnings } from '../config/load-config.js';
7
+ import { RunRequestInvalid, } from '../domain/errors.js';
8
+ import { newRunId } from '../domain/run-id.js';
9
+ import { startRun } from '../domain/run-state.js';
10
+ import { finalStatus } from '../flow/define-flow.js';
11
+ import { runEngine } from '../flow/engine.js';
12
+ import { runFlow } from '../flow/run-flow.js';
13
+ import { getCurrentBranch } from '../git/branch.js';
14
+ import { withRunScope } from './container.js';
15
+ import { openRunStore } from './run-stores.js';
16
+ import { ensureSandboxImage } from './sandbox-image.js';
17
+ /**
18
+ * Runs `input` to its next stop. The whole run holds the run's lock, so a second
19
+ * process for the same id fails with `RunInProgress` instead of writing over it. A run that
20
+ * already ended is reported as it is, without touching the sandbox.
21
+ */
22
+ export async function runJig(app, input) {
23
+ const target = targetOf(input);
24
+ const releaseLock = await lockRun(app.cradle.repoRoot, target.runId);
25
+ if (releaseLock.isErr())
26
+ return Result.err(releaseLock.error);
27
+ try {
28
+ return await runLocked(app, target);
29
+ }
30
+ finally {
31
+ await releaseLock.value();
32
+ }
33
+ }
34
+ function targetOf(input) {
35
+ if ('resume' in input)
36
+ return { runId: input.resume };
37
+ const { start } = input;
38
+ return { request: start.text, runId: input.runId ?? newRunId(start) };
39
+ }
40
+ function runLocked(app, target) {
41
+ return Result.gen(async function* () {
42
+ const store = yield* Result.await(openRunStore(app.cradle));
43
+ const state = yield* Result.await(startOrResume(app.cradle, store, target));
44
+ for (const warning of validationWarnings(app.cradle.config))
45
+ app.cradle.logger.warn(warning);
46
+ const finished = finalStatus(runFlow, state);
47
+ const report = finished
48
+ ? { state, status: finished }
49
+ : yield* Result.await(advance(app, store, state));
50
+ yield* Result.await(recordInvocation(app.cradle, report));
51
+ return Result.ok(report);
52
+ });
53
+ }
54
+ async function startOrResume(cradle, store, { runId, request }) {
55
+ const existing = await store.load(runId);
56
+ if (existing.isErr())
57
+ return Result.err(existing.error);
58
+ if (request === undefined) {
59
+ return existing.value
60
+ ? Result.ok(existing.value)
61
+ : Result.err(new RunRequestInvalid({ message: `No run found with id "${runId}".` }));
62
+ }
63
+ if (!existing.value)
64
+ return startNewRun(cradle, store, runId, request);
65
+ if (request !== existing.value.request) {
66
+ return Result.err(new RunRequestInvalid({
67
+ message: `Run "${runId}" was started from a different request — pass a new --id to start a new run.`,
68
+ }));
69
+ }
70
+ return Result.ok(existing.value);
71
+ }
72
+ async function startNewRun(cradle, store, runId, request) {
73
+ const baseBranch = await getCurrentBranch(cradle.repoRoot);
74
+ if (baseBranch.isErr())
75
+ return Result.err(baseBranch.error);
76
+ const started = startRun({ runId, baseBranch: baseBranch.value, request });
77
+ const saved = await store.save(started);
78
+ return saved.isErr() ? Result.err(saved.error) : Result.ok(started);
79
+ }
80
+ async function advance(app, store, state) {
81
+ const credentials = stepCredentials(app.cradle.config, app.cradle.environment);
82
+ if (credentials.isErr())
83
+ return Result.err(credentials.error);
84
+ const image = await ensureSandboxImage(app.cradle);
85
+ if (image.isErr())
86
+ return Result.err(image.error);
87
+ const telemetry = await startTelemetry(app.cradle.environment.telemetry);
88
+ try {
89
+ return await withRunScope(app, state, store, { tracer: telemetry?.tracer }, (dependencies) => runEngine(runFlow, state, dependencies));
90
+ }
91
+ finally {
92
+ await telemetry?.shutdown();
93
+ }
94
+ }
95
+ /** Leaves this machine's record of where the invocation stopped; see `RunArtefacts`. */
96
+ async function recordInvocation({ repoRoot, artefacts }, report) {
97
+ const metrics = new MetricsLog(repoRoot, report.state.runId).summary();
98
+ if (metrics.isErr())
99
+ return Result.err(metrics.error);
100
+ return artefacts.write(report.state, report.status, metrics.value);
101
+ }
@@ -0,0 +1,20 @@
1
+ import { Result } from 'better-result';
2
+ import { MetricsLog } from '../adapters/local-store/metrics-log.js';
3
+ import { RunRequestInvalid } from '../domain/errors.js';
4
+ import { openRunStore } from './run-stores.js';
5
+ /**
6
+ * Where a run is, read from the same stores a run saves to without changing any of them or this
7
+ * machine's refs; metrics are this machine's.
8
+ */
9
+ export async function readRunStatus(app, runId) {
10
+ return Result.gen(async function* () {
11
+ const store = yield* Result.await(openRunStore(app.cradle));
12
+ const state = yield* Result.await(store.peek(runId));
13
+ if (!state) {
14
+ return Result.err(new RunRequestInvalid({ message: `No run found with id "${runId}".` }));
15
+ }
16
+ const { repoRoot, artefacts } = app.cradle;
17
+ const metrics = yield* new MetricsLog(repoRoot, runId).summary();
18
+ return Result.ok({ state, documents: artefacts.documents(runId), metrics });
19
+ });
20
+ }