@refleet-it/runner 0.1.199 → 0.1.200

package/dist/backends/claude.js

@@ -1,5 +1,5 @@
 import { spawn } from 'node:child_process';
-import { AgentExecutionError } from './types.js';
+import { agentEnv, AgentExecutionError } from './types.js';
 /**
  * Builds the `claude` CLI argument list for one job kind. Ported 1:1 from
  * runner/claude/entrypoint.sh's build_claude_args/build_kind_claude_args: qualification
@@ -107,6 +107,7 @@ export class ClaudeBackend {
             let buffer = '';
             const child = this.spawnFn(this.executablePath, args, {
                 cwd: opts.cwd,
+                env: agentEnv(this.env),
                 stdio: ['ignore', 'pipe', 'inherit'],
             });
             child.stdout.setEncoding('utf8');

package/dist/backends/kiro.js

@@ -1,5 +1,5 @@
 import { spawn } from 'node:child_process';
-import { AgentExecutionError } from './types.js';
+import { agentEnv, AgentExecutionError } from './types.js';
 /**
  * Pulls the ACP session id out of a `session/new` (or `session/load`) response.
  * Pure/testable in isolation from the actual JSON-RPC transport.
@@ -177,7 +177,7 @@ export class KiroBackend {
         // protocol-native session/request_permission (see AcpConnection.handlePeerRequest).
         const child = this.spawnFn(this.executablePath, ['acp'], {
             cwd: opts.cwd,
-            env: this.env,
+            env: agentEnv(this.env),
             stdio: ['pipe', 'pipe', 'inherit'],
         });
         const chunks = [];

package/dist/backends/types.js

@@ -1,2 +1,11 @@
 export class AgentExecutionError extends Error {
 }
+/**
+ * The agent runs untrusted code and prompts from a customer repository with tool
+ * permissions switched off, so anything it can read from its environment it can also be
+ * talked into exfiltrating. The runner's own credentials — the API key that fetches
+ * GitLab tokens — have no business there.
+ */
+export function agentEnv(env) {
+    return Object.fromEntries(Object.entries(env).filter(([name]) => !name.startsWith('REFLEET_')));
+}

package/dist/fleet/api.js

@@ -92,8 +92,10 @@ export class FleetApi {
         }
     }
     /**
-     * Fetched per job rather than once at startup so a reconnected/rotated GitLab
-     * token is picked up without restarting the runner.
+     * Fetched right before every git/GitLab call rather than once per job or at startup:
+     * OAuth-backed connections hand out short-lived access tokens, and the backend refreshes
+     * one only when asked for it, so a token fetched before a long agent run may be dead by
+     * the time the branch is pushed.
      */
     async fetchGitLabCredentials() {
         const response = await this.request('GET', '/runner/gitlab-credentials');

package/dist/fleet/git.js

@@ -11,18 +11,25 @@ export class GitError extends Error {
     }
 }
 /**
- * GitLab's git-http backend (unlike its REST API) does not accept the PRIVATE-TOKEN
+ * GitLab's git-http backend (unlike its REST API) does not accept a bearer/private token
  * header — it only honors HTTP Basic auth, so the token is sent as a Basic credential
- * (any non-empty username works). Passed per invocation as `-c http.extraHeader` so it
- * is never written into the cached checkout's git config.
+ * (the `oauth2` username works for both OAuth and personal/group access tokens).
+ * Handed to git through GIT_CONFIG_* environment variables rather than `-c` on the
+ * command line, so it is never written into the cached checkout's git config, never
+ * visible in `ps`, and never part of the argv a GitError echoes back into logs and job
+ * failure reports.
  */
-export function gitAuthConfig(accessToken) {
+export function gitAuthEnv(accessToken) {
     const basic = Buffer.from(`oauth2:${accessToken}`).toString('base64');
-    return ['-c', `http.extraHeader=Authorization: Basic ${basic}`];
+    return {
+        GIT_CONFIG_COUNT: '1',
+        GIT_CONFIG_KEY_0: 'http.extraHeader',
+        GIT_CONFIG_VALUE_0: `Authorization: Basic ${basic}`,
+    };
 }
 export function createGitRunner(execFileFn = execFile) {
-    return (args, cwd) => new Promise((resolve, reject) => {
-        execFileFn('git', args, { cwd, maxBuffer: 64 * 1024 * 1024, env: { ...process.env, GIT_TERMINAL_PROMPT: '0' } }, (error, stdout, stderr) => {
+    return (args, cwd, env = {}) => new Promise((resolve, reject) => {
+        execFileFn('git', args, { cwd, maxBuffer: 64 * 1024 * 1024, env: { ...process.env, GIT_TERMINAL_PROMPT: '0', ...env } }, (error, stdout, stderr) => {
             if (error) {
                 const code = 'code' in error && 'number' === typeof error.code ? error.code : null;
                 reject(new GitError(args, code, String(stderr)));

package/dist/fleet/gitlab.js

@@ -19,7 +19,7 @@ async function gitlabRequest(credentials, fetchFn, method, path, body) {
     return fetchFn(`${apiBase(credentials)}${path}`, {
         method,
         headers: {
-            'PRIVATE-TOKEN': credentials.accessToken,
+            Authorization: `Bearer ${credentials.accessToken}`,
             'Content-Type': 'application/json',
         },
         body: undefined === body ? undefined : JSON.stringify(body),

package/dist/fleet/job.js

@@ -83,9 +83,16 @@ export async function claimAndRunJob(deps) {
         }
         return;
     }
-    await publishAndReport(deps, job, credentials, repoDir, project, output, report);
+    await publishAndReport(deps, job, repoDir, project, output, report);
 }
-async function publishAndReport(deps, job, credentials, repoDir, project, output, report) {
+async function publishAndReport(deps, job, repoDir, project, output, report) {
+    // The agent may have run for longer than the access token fetched for the clone lives.
+    const credentials = await deps.api.fetchGitLabCredentials();
+    if (!credentials) {
+        deps.log(`job ${job.jobId}: failed to fetch GitLab credentials from Slipway before publishing`);
+        await report('failure', 'Failed to fetch GitLab credentials from Slipway', { errorMessage: 'gitlab credentials fetch failed' });
+        return;
+    }
     let published;
     try {
         published = await (deps.publishChange ?? defaultPublishChange)(deps.workspace, credentials, repoDir, project, job.ownerTargetId ?? '', `Apply Slipway shift ${job.ownerId ?? ''}`, tail(output), deps.fetchFn);

package/dist/fleet/workspace.js

@@ -1,6 +1,6 @@
 import { appendFileSync, existsSync, mkdirSync, readdirSync, readFileSync, rmSync, statSync, utimesSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
-import { gitAuthConfig } from './git.js';
+import { gitAuthEnv } from './git.js';
 import { createMergeRequest, ensureRefleetLabel, REFLEET_LABEL } from './gitlab.js';
 const LAST_USED_MARKER = '.slipway-last-used';
 function directorySizeBytes(dir) {
@@ -82,10 +82,10 @@ function excludeMarkerFromGit(repoDir) {
 /** Returns the ready-to-use working directory; throws (GitError) when any git step fails. */
 export async function syncRepo(workspace, credentials, project) {
     const repoDir = join(workspace.cacheDir, project.externalId);
-    const auth = gitAuthConfig(credentials.accessToken);
+    const auth = gitAuthEnv(credentials.accessToken);
     if (existsSync(join(repoDir, '.git'))) {
         workspace.log(`reusing cached checkout for ${project.path}`);
-        await workspace.git([...auth, 'fetch', '--prune', 'origin'], repoDir);
+        await workspace.git(['fetch', '--prune', 'origin'], repoDir, auth);
         await workspace.git(['checkout', '-f', project.defaultBranch], repoDir);
         await workspace.git(['reset', '--hard', `origin/${project.defaultBranch}`], repoDir);
         await workspace.git(['clean', '-fdx'], repoDir);
@@ -95,7 +95,7 @@ export async function syncRepo(workspace, credentials, project) {
         evictLruUntilUnderCap(workspace);
         workspace.log(`cloning ${project.path} (first use on this runner)`);
         const cloneUrl = `${credentials.baseUrl.replace(/\/+$/, '')}/${project.path}.git`;
-        await workspace.git([...auth, 'clone', '--origin', 'origin', cloneUrl, repoDir]);
+        await workspace.git(['clone', '--origin', 'origin', cloneUrl, repoDir], undefined, auth);
     }
     touchMarker(repoDir);
     excludeMarkerFromGit(repoDir);
@@ -118,7 +118,7 @@ export async function publishChange(workspace, credentials, repoDir, project, sh
         return null;
     }
     await workspace.git(['-c', 'user.name=Slipway', '-c', 'user.email=slipway@localhost', 'commit', '-m', title], repoDir);
-    await workspace.git([...gitAuthConfig(credentials.accessToken), 'push', '--force', 'origin', `HEAD:refs/heads/${branchName}`], repoDir);
+    await workspace.git(['push', '--force', 'origin', `HEAD:refs/heads/${branchName}`], repoDir, gitAuthEnv(credentials.accessToken));
     // Without the label in place GitLab would create it in a random colour, so the MR
     // rather goes out unlabelled than off-brand.
     const labelled = await ensureRefleetLabel(credentials, project.externalId, fetchFn);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@refleet-it/runner",
-  "version": "0.1.199",
+  "version": "0.1.200",
   "description": "Refleet fleet runner: claims code-modernisation jobs from the Refleet API and runs them through Claude Code or Kiro on your own machine.",
   "keywords": [
     "refleet",