@delegoapp/runner 0.1.0

package/dist/relay-client.js

@@ -0,0 +1,84 @@
+export class RelayUnauthorizedError extends Error {
+    endpoint;
+    constructor(endpoint) {
+        super(`relay rejected request to ${endpoint} (HTTP 401)`);
+        this.endpoint = endpoint;
+        this.name = 'RelayUnauthorizedError';
+    }
+}
+export async function postJson(config, pathname, body) {
+    const url = `${config.relayUrl}${pathname}`;
+    let response;
+    try {
+        response = await fetch(url, {
+            method: 'POST',
+            headers: {
+                'content-type': 'application/json',
+                authorization: `Bearer ${config.bearer}`,
+            },
+            body: JSON.stringify(body),
+        });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`Unable to reach relay endpoint ${url}: ${message}`);
+    }
+    if (response.status === 401) {
+        throw new RelayUnauthorizedError(pathname);
+    }
+    const payload = (await response.json().catch(() => ({})));
+    if (!response.ok) {
+        throw new Error(payload.error ?? `Relay returned HTTP ${response.status}`);
+    }
+    return payload;
+}
+export async function postRunnerEvent(config, pathname, activeJobId = null) {
+    return postJson(config, pathname, {
+        version: config.version,
+        supportedExecutors: config.supportedExecutors,
+        activeJobId,
+    });
+}
+export function describeRunnerResponse(action, response) {
+    if (!response.runner) {
+        return `${action}: relay accepted request`;
+    }
+    const heartbeat = response.runner.lastHeartbeatAt ?? 'not recorded';
+    return `${action}: ${response.runner.id} is ${response.runner.status}, heartbeat ${heartbeat}`;
+}
+export async function reportProgress(config, job, summary, metadata = {}) {
+    await postJson(config, '/api/runner/jobs/progress', {
+        jobId: job.id,
+        organizationId: job.organizationId,
+        summary,
+        metadata: {
+            attemptId: job.attemptId,
+            ...metadata,
+        },
+    });
+}
+export async function reportCompletion(config, job, summary, metadata) {
+    await postJson(config, '/api/runner/jobs/complete', {
+        jobId: job.id,
+        organizationId: job.organizationId,
+        agentSessionId: job.agentSessionId,
+        summary,
+        metadata,
+    });
+}
+export async function reportFailure(config, job, summary, metadata, cancelled = false) {
+    await postJson(config, '/api/runner/jobs/fail', {
+        jobId: job.id,
+        organizationId: job.organizationId,
+        agentSessionId: job.agentSessionId,
+        summary,
+        cancelled,
+        metadata,
+    });
+}
+export async function pollCancellation(config, job) {
+    const status = await postJson(config, '/api/runner/jobs/status', {
+        jobId: job.id,
+    });
+    return Boolean(status.job?.cancellationRequested);
+}

package/dist/run.js

@@ -0,0 +1,143 @@
+import { readConfig, usageMessage, } from './config.js';
+import { getProfile, readStore, resolveCredentialsPath, } from './credentials-store.js';
+import { runMockExecutionOnce, runRealExecutionOnce } from './job-pipeline.js';
+import { pairAndStore } from './pairing.js';
+import { describeRunnerResponse, postRunnerEvent, RelayUnauthorizedError, } from './relay-client.js';
+function sleep(ms) {
+    return new Promise((resolve) => {
+        setTimeout(resolve, ms);
+    });
+}
+export async function resolveRunnerConfig(input, env = process.env) {
+    const credentialsPath = resolveCredentialsPath(env);
+    if (input.pairingToken) {
+        if (!input.relayUrl) {
+            throw new Error('--relay-url is required when --pairing-token is supplied');
+        }
+        const result = await pairAndStore({
+            relayUrl: input.relayUrl,
+            pairingToken: input.pairingToken,
+            profileName: input.profileName,
+            version: input.version,
+            supportedExecutors: input.supportedExecutors,
+            credentialsPath,
+        });
+        if (result.orphanedRunnerId && !input.force) {
+            console.warn(`delego-runner: overwrote profile ${input.profileName}. ` +
+                `Old runner ${result.orphanedRunnerId} is still in the dashboard; remove it manually if unwanted. ` +
+                `Pass --force to suppress this warning.`);
+        }
+        return buildRunnerConfig(input, result.relayUrl, result.bearer, result.runnerId);
+    }
+    const store = readStore(credentialsPath);
+    const profile = getProfile(store, input.profileName);
+    if (!profile) {
+        throw new Error(`delego-runner: profile ${JSON.stringify(input.profileName)} not paired. ` +
+            `Re-run with --pairing-token <drs_pair_...> from the dashboard to pair it.`);
+    }
+    if (input.relayUrl && input.relayUrl !== profile.relayUrl) {
+        throw new Error(`delego-runner: --relay-url (${input.relayUrl}) does not match the relay this profile was paired against (${profile.relayUrl}). ` +
+            `Use --pairing-token to re-pair against the new relay, or pass the matching --relay-url.`);
+    }
+    return buildRunnerConfig(input, profile.relayUrl, profile.bearer, profile.runnerId);
+}
+function buildRunnerConfig(input, relayUrl, bearer, runnerId) {
+    return {
+        relayUrl,
+        bearer,
+        runnerId,
+        profileName: input.profileName,
+        once: input.once,
+        mockExecuteOnce: input.mockExecuteOnce,
+        heartbeatIntervalMs: input.heartbeatIntervalMs,
+        pollIntervalMs: input.pollIntervalMs,
+        cancellationPollIntervalMs: input.cancellationPollIntervalMs,
+        workspaceRoot: input.workspaceRoot,
+        gitCloneBaseUrl: input.gitCloneBaseUrl,
+        executors: input.executors,
+        executorTimeoutMs: input.executorTimeoutMs,
+        createCommit: input.createCommit,
+        version: input.version,
+        supportedExecutors: input.supportedExecutors,
+    };
+}
+function handleUnauthorized(error, config, profileName) {
+    console.error(`delego-runner: runner credential rejected by relay (HTTP 401 on ${error.endpoint}). ` +
+        `The runner may have been rotated or removed in the dashboard. ` +
+        `Re-pair with --pairing-token to recover.\n` +
+        `Profile: ${profileName} · Runner: ${config.runnerId} · Relay: ${config.relayUrl}`);
+    process.exit(2);
+}
+export async function run(args = process.argv.slice(2)) {
+    if (args.includes('--help') || args.includes('-h')) {
+        console.log(usageMessage());
+        return;
+    }
+    const input = readConfig(args);
+    const config = await resolveRunnerConfig(input);
+    // In v0.3, /api/runner/register is the *pairing* endpoint and only accepts a
+    // pairing-token body. Pairing happens once inside resolveRunnerConfig (when
+    // --pairing-token is supplied); after that the runner just heartbeats.
+    try {
+        const heartbeat = await postRunnerEvent(config, '/api/runner/heartbeat');
+        console.log(describeRunnerResponse('heartbeat', heartbeat));
+    }
+    catch (error) {
+        if (error instanceof RelayUnauthorizedError) {
+            handleUnauthorized(error, config, input.profileName);
+        }
+        throw error;
+    }
+    if (config.mockExecuteOnce) {
+        await runMockExecutionOnce(config);
+        return;
+    }
+    const heartbeatTimer = startHeartbeatLoop(config, input.profileName);
+    try {
+        do {
+            let handled = false;
+            try {
+                handled = await runRealExecutionOnce(config);
+            }
+            catch (error) {
+                if (error instanceof RelayUnauthorizedError) {
+                    handleUnauthorized(error, config, input.profileName);
+                }
+                const message = error instanceof Error ? error.message : String(error);
+                console.warn(`poll cycle failed: ${message}`);
+                if (config.once) {
+                    throw error;
+                }
+            }
+            if (config.once) {
+                return;
+            }
+            await sleep(handled ? 1_000 : config.pollIntervalMs);
+            // oxlint-disable-next-line no-constant-condition
+        } while (true);
+    }
+    finally {
+        clearInterval(heartbeatTimer);
+    }
+}
+function startHeartbeatLoop(config, profileName) {
+    let inFlight = false;
+    return setInterval(async () => {
+        if (inFlight)
+            return;
+        inFlight = true;
+        try {
+            const response = await postRunnerEvent(config, '/api/runner/heartbeat', null);
+            console.log(describeRunnerResponse('heartbeat', response));
+        }
+        catch (error) {
+            if (error instanceof RelayUnauthorizedError) {
+                handleUnauthorized(error, config, profileName);
+            }
+            console.warn(`heartbeat failed: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        finally {
+            inFlight = false;
+        }
+    }, config.heartbeatIntervalMs);
+}

package/dist/thinking.js

@@ -0,0 +1,24 @@
+export function normalizeThinkingPreference(value) {
+    if (typeof value !== 'string') {
+        return null;
+    }
+    const normalized = value.trim().toLowerCase();
+    if (normalized === 'low' ||
+        normalized === 'medium' ||
+        normalized === 'high') {
+        return normalized;
+    }
+    return null;
+}
+export function promptThinkingInstruction(thinking) {
+    if (thinking === 'low') {
+        return 'Thinking level: low. Prefer a direct approach and minimize exploration unless required.';
+    }
+    if (thinking === 'medium') {
+        return 'Thinking level: medium. Balance speed with enough reasoning to validate the implementation.';
+    }
+    if (thinking === 'high') {
+        return 'Thinking level: high. Spend extra effort on validation, edge cases, and correctness before finishing.';
+    }
+    return null;
+}

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@delegoapp/runner",
+  "version": "0.1.0",
+  "private": false,
+  "description": "Delego runner — polls the Delego relay and executes Linear-delegated coding jobs via Codex CLI or Claude Code.",
+  "keywords": [
+    "agent",
+    "claude",
+    "codex",
+    "delego",
+    "linear",
+    "runner"
+  ],
+  "license": "UNLICENSED",
+  "bin": {
+    "delego-runner": "dist/bin.js"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "type": "module",
+  "imports": {
+    "#*.js": {
+      "types": "./src/*.ts",
+      "source": "./src/*.ts",
+      "default": "./dist/*.js"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "typescript": "^6.0.3",
+    "vitest": "^4.1.5",
+    "@kit/tsconfig": "0.1.0"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json && node scripts/add-shebang.mjs",
+    "prestart": "pnpm build",
+    "start": "node dist/index.js",
+    "typecheck": "tsc --noEmit -p tsconfig.json",
+    "test": "vitest run",
+    "clean": "rm -rf .turbo dist node_modules"
+  }
+}