@danneillouven/remote-workspace 0.0.0-stage → 0.1.0

package/runtime/server/src/modules/auth/auth-service.js

@@ -0,0 +1,96 @@
+import { randomBytes, timingSafeEqual } from 'node:crypto';
+import { AppError } from "../../lib/errors.js";
+import { hashPassword, passwordNeedsUpgrade, verifyPassword } from "./password.js";
+function safeEqual(a, b) {
+    const left = Buffer.from(a);
+    const right = Buffer.from(b);
+    return left.length === right.length && timingSafeEqual(left, right);
+}
+/**
+ * The single account's password and first-run setup. Until a password exists
+ * the server is in setup mode: the only way to claim it is the one-time token
+ * printed to the server's console (and saved in DATA_DIR/setup-token), so
+ * reaching the URL first — e.g. from elsewhere on the tailnet — is not enough.
+ */
+export class AuthService {
+    #store;
+    #tokens;
+    #logger;
+    #terminateTerminals;
+    #setupToken = null;
+    constructor(store, tokens, logger, terminateTerminals = () => undefined) {
+        this.#store = store;
+        this.#tokens = tokens;
+        this.#logger = logger;
+        this.#terminateTerminals = terminateTerminals;
+        if (this.setupRequired) {
+            this.#setupToken = randomBytes(24).toString('base64url');
+            store.writeSetupToken(this.#setupToken);
+        }
+        else {
+            store.deleteSetupToken();
+        }
+    }
+    get setupRequired() {
+        return this.#store.state.auth === null;
+    }
+    /** The one-time token that authorizes creating the first password (null once set up). */
+    get setupToken() {
+        return this.#setupToken;
+    }
+    async completeSetup(token, password) {
+        if (!this.setupRequired || !this.#setupToken)
+            throw new AppError('CONFLICT', 'Setup is already complete. Sign in instead.');
+        if (!safeEqual(token, this.#setupToken)) {
+            throw new AppError('FORBIDDEN', 'Invalid setup token. Copy the link printed by the server when it started.');
+        }
+        const passwordHash = await hashPassword(password);
+        // Re-check after the (slow) hash so two concurrent requests cannot both succeed.
+        if (!this.setupRequired)
+            throw new AppError('CONFLICT', 'Setup is already complete. Sign in instead.');
+        this.#store.update((draft) => {
+            draft.auth = { passwordHash };
+        });
+        this.#setupToken = null;
+        this.#store.deleteSetupToken();
+        this.#logger.info('initial password created; setup complete');
+    }
+    async verifyPassword(password) {
+        const auth = this.#store.state.auth;
+        if (!auth)
+            throw new AppError('SETUP_REQUIRED', 'Finish setup first.');
+        const valid = await verifyPassword(password, auth.passwordHash);
+        if (this.#store.state.auth?.passwordHash !== auth.passwordHash)
+            return false;
+        if (valid && passwordNeedsUpgrade(auth.passwordHash)) {
+            const upgraded = await hashPassword(password);
+            // A concurrent password change must never be overwritten by a login.
+            if (this.#store.state.auth?.passwordHash !== auth.passwordHash)
+                return false;
+            this.#store.update((draft) => { if (draft.auth)
+                draft.auth.passwordHash = upgraded; });
+        }
+        return valid && this.#store.state.auth !== null;
+    }
+    async signOutAll(password) {
+        if (!(await this.verifyPassword(password)))
+            throw new AppError('FORBIDDEN', 'Current password is incorrect.');
+        this.#terminateTerminals();
+        this.#tokens.revokeAll();
+    }
+    /** Change the password and revoke all previous sessions. */
+    async changePassword(currentPassword, newPassword) {
+        if (!(await this.verifyPassword(currentPassword)))
+            throw new AppError('FORBIDDEN', 'Current password is incorrect.');
+        const previousHash = this.#store.state.auth?.passwordHash;
+        const passwordHash = await hashPassword(newPassword);
+        if (this.#store.state.auth?.passwordHash !== previousHash)
+            throw new AppError('FORBIDDEN', 'The password changed. Sign in again.');
+        this.#store.update((draft) => {
+            draft.auth = { passwordHash };
+        });
+        this.#terminateTerminals();
+        this.#tokens.revokeAll();
+        this.#logger.info('password changed; all sessions signed out');
+    }
+}

package/runtime/server/src/modules/auth/auth.routes.js

@@ -0,0 +1,108 @@
+import { changePasswordRequestSchema, loginRequestSchema, setupRequestSchema, signOutAllRequestSchema, } from "../../../../src/schema/auth.js";
+import { AppError } from "../../lib/errors.js";
+import { parseInput } from "../../lib/validation.js";
+import { SESSION_COOKIE } from "./auth-security.js";
+export function registerAuthRoutes(app, config, auth, tokens, limiter) {
+    // 'auto': Secure whenever the browser reached us over HTTPS (directly or via tailscale serve).
+    const isSecure = (request) => config.auth.cookieSecure === 'auto'
+        ? request.protocol === 'https' || (request.headers.origin ?? '').startsWith('https:')
+        : config.auth.cookieSecure;
+    const cookieOptions = (request) => ({
+        httpOnly: true,
+        sameSite: 'strict',
+        secure: isSecure(request),
+        path: '/',
+    });
+    const startSession = (request, reply) => {
+        reply.setCookie(SESSION_COOKIE, tokens.issue(), { ...cookieOptions(request), maxAge: Math.floor(tokens.ttlMs / 1000) });
+    };
+    async function limited(request, reply, operation) {
+        const retryAfterMs = limiter.retryAfter(request.ip);
+        if (retryAfterMs > 0) {
+            reply.header('Retry-After', Math.ceil(retryAfterMs / 1000));
+            throw new AppError('TOO_MANY_REQUESTS', 'Too many failed attempts. Try again later.');
+        }
+        let release;
+        try {
+            release = limiter.acquire(request.ip);
+        }
+        catch (error) {
+            reply.header('Retry-After', '1');
+            throw error;
+        }
+        try {
+            return await operation();
+        }
+        finally {
+            release();
+        }
+    }
+    app.post('/api/auth/setup', (request, reply) => limited(request, reply, async () => {
+        const { token, password } = parseInput(setupRequestSchema, request.body);
+        try {
+            await auth.completeSetup(token, password);
+        }
+        catch (error) {
+            if (error instanceof AppError && error.code === 'FORBIDDEN') {
+                limiter.recordFailure(request.ip);
+                request.log.warn({ ip: request.ip }, 'setup attempted with an invalid token');
+            }
+            throw error;
+        }
+        startSession(request, reply);
+        reply.status(204).send();
+    }));
+    app.post('/api/auth/login', (request, reply) => limited(request, reply, async () => {
+        const { password } = parseInput(loginRequestSchema, request.body);
+        if (!(await auth.verifyPassword(password))) {
+            limiter.recordFailure(request.ip);
+            request.log.warn({ ip: request.ip }, 'failed login attempt');
+            throw new AppError('UNAUTHORIZED', 'Incorrect password.');
+        }
+        limiter.recordSuccess(request.ip);
+        startSession(request, reply);
+        request.log.info({ ip: request.ip }, 'login succeeded');
+        reply.status(204).send();
+    }));
+    app.post('/api/auth/logout', async (request, reply) => {
+        tokens.revoke(request.cookies[SESSION_COOKIE]);
+        reply.clearCookie(SESSION_COOKIE, cookieOptions(request));
+        reply.status(204).send();
+    });
+    app.post('/api/auth/activity', async (request, reply) => {
+        tokens.touch(request.cookies[SESSION_COOKIE]);
+        reply.status(204).send();
+    });
+    app.post('/api/auth/logout-all', (request, reply) => limited(request, reply, async () => {
+        const { password } = parseInput(signOutAllRequestSchema, request.body);
+        try {
+            await auth.signOutAll(password);
+        }
+        catch (error) {
+            if (error instanceof AppError && error.code === 'FORBIDDEN')
+                limiter.recordFailure(request.ip);
+            throw error;
+        }
+        limiter.recordSuccess(request.ip);
+        reply.clearCookie(SESSION_COOKIE, cookieOptions(request));
+        reply.status(204).send();
+    }));
+    app.get('/api/auth/session', async (request) => {
+        return { authenticated: tokens.verify(request.cookies[SESSION_COOKIE]), setupRequired: auth.setupRequired };
+    });
+    app.post('/api/auth/password', (request, reply) => limited(request, reply, async () => {
+        const { currentPassword, newPassword } = parseInput(changePasswordRequestSchema, request.body);
+        try {
+            await auth.changePassword(currentPassword, newPassword);
+        }
+        catch (error) {
+            if (error instanceof AppError && error.code === 'FORBIDDEN')
+                limiter.recordFailure(request.ip);
+            throw error;
+        }
+        limiter.recordSuccess(request.ip);
+        // Every other session is now invalid; keep this one signed in with a fresh cookie.
+        startSession(request, reply);
+        reply.status(204).send();
+    }));
+}

package/runtime/server/src/modules/auth/login-limiter.js

@@ -0,0 +1,40 @@
+import { AppError } from "../../lib/errors.js";
+const WINDOW_MS = 15 * 60 * 1000;
+const FREE_ATTEMPTS = 5;
+const MAX_LOCK_MS = 15 * 60 * 1000;
+const MAX_ENTRIES = 1000;
+/** Per-source backoff plus bounded concurrent password work, without an account-wide failure lockout. */
+export class LoginLimiter {
+    #entries = new Map();
+    #active = new Set();
+    retryAfter(key, now = Date.now()) {
+        const entry = this.#entries.get(key);
+        return entry ? Math.max(0, entry.lockedUntil - now) : 0;
+    }
+    acquire(key) {
+        if (this.#active.size >= 2 || this.#active.has(key)) {
+            throw new AppError('TOO_MANY_REQUESTS', 'Authentication is busy. Try again shortly.');
+        }
+        this.#active.add(key);
+        return () => { this.#active.delete(key); };
+    }
+    recordFailure(key, now = Date.now()) {
+        let entry = this.#entries.get(key);
+        if (!entry || now - entry.firstFailureAt > WINDOW_MS) {
+            if (!entry && this.#entries.size >= MAX_ENTRIES) {
+                const oldest = this.#entries.keys().next().value;
+                if (oldest !== undefined)
+                    this.#entries.delete(oldest);
+            }
+            entry = { failures: 0, firstFailureAt: now, lockedUntil: 0 };
+            this.#entries.set(key, entry);
+        }
+        entry.failures += 1;
+        if (entry.failures >= FREE_ATTEMPTS) {
+            entry.lockedUntil = now + Math.min(MAX_LOCK_MS, 1000 * 2 ** Math.min(20, entry.failures - FREE_ATTEMPTS));
+        }
+    }
+    recordSuccess(key) {
+        this.#entries.delete(key);
+    }
+}

package/runtime/server/src/modules/auth/password.js

@@ -0,0 +1,29 @@
+import { randomBytes, scrypt, timingSafeEqual } from 'node:crypto';
+// scrypt cost parameters; 128 * N * r bytes (32 MiB) of memory per hash.
+const N = 32_768;
+const R = 8;
+const P = 3;
+const KEY_LENGTH = 32;
+const MAX_MEMORY = 64 * 1024 * 1024;
+function derive(password, salt, n, r, p, keyLength) {
+    return new Promise((resolve, reject) => {
+        scrypt(password, salt, keyLength, { N: n, r, p, maxmem: MAX_MEMORY }, (error, key) => (error ? reject(error) : resolve(key)));
+    });
+}
+/** Hash a password as `scrypt$N$r$p$<salt b64>$<hash b64>`. */
+export async function hashPassword(password) {
+    const salt = randomBytes(16);
+    const hash = await derive(password, salt, N, R, P, KEY_LENGTH);
+    return ['scrypt', N, R, P, salt.toString('base64'), hash.toString('base64')].join('$');
+}
+export async function verifyPassword(password, encoded) {
+    const [scheme, n, r, p, saltB64, hashB64] = encoded.split('$');
+    if (scheme !== 'scrypt' || !saltB64 || !hashB64)
+        return false;
+    const expected = Buffer.from(hashB64, 'base64');
+    const actual = await derive(password, Buffer.from(saltB64, 'base64'), Number(n), Number(r), Number(p), expected.length);
+    return timingSafeEqual(actual, expected);
+}
+export function passwordNeedsUpgrade(encoded) {
+    return !encoded.startsWith(`scrypt$${N}$${R}$${P}$`);
+}

package/runtime/server/src/modules/auth/session-tokens.js

@@ -0,0 +1,90 @@
+import { createHash, randomBytes } from 'node:crypto';
+const MAX_SESSIONS = 32;
+const TOUCH_WRITE_INTERVAL_MS = 15_000;
+/** Opaque bearer tokens. Only their SHA-256 hashes are persisted; legacy signed tokens are rejected. */
+export class SessionTokens {
+    #store;
+    #ttlMs;
+    #idleMs;
+    #activity = new Map();
+    #listeners = new Set();
+    constructor(store, ttlMs, idleMs) {
+        this.#store = store;
+        this.#ttlMs = ttlMs;
+        this.#idleMs = idleMs;
+    }
+    get ttlMs() { return this.#ttlMs; }
+    #hash(token) {
+        return token && /^[A-Za-z0-9_-]{43}$/.test(token) ? createHash('sha256').update(token).digest('hex') : null;
+    }
+    #find(token) {
+        const hash = this.#hash(token);
+        return hash ? this.#store.state.sessions.find((session) => session.hash === hash) : undefined;
+    }
+    remainingMs(token, now = Date.now()) {
+        const session = this.#find(token);
+        if (!session)
+            return 0;
+        const lastActive = this.#activity.get(session.hash) ?? session.lastActiveAt;
+        return Math.max(0, Math.min(session.expiresAt, session.createdAt + this.#ttlMs, lastActive + this.#idleMs) - now);
+    }
+    verify(token, now = Date.now()) {
+        return this.remainingMs(token, now) > 0;
+    }
+    issue(now = Date.now()) {
+        const token = randomBytes(32).toString('base64url');
+        const hash = this.#hash(token);
+        const expired = this.#store.state.sessions.filter((session) => !this.#validRecord(session, now)).map((session) => session.hash);
+        const kept = this.#store.state.sessions.filter((session) => !expired.includes(session.hash));
+        const evicted = kept.length >= MAX_SESSIONS ? kept.splice(0, kept.length - MAX_SESSIONS + 1) : [];
+        this.#store.update((draft) => {
+            draft.sessions = [...kept, { hash, createdAt: now, expiresAt: now + this.#ttlMs, lastActiveAt: now }];
+        });
+        for (const removed of [...expired, ...evicted.map((session) => session.hash)])
+            this.#notify(removed);
+        return token;
+    }
+    #validRecord(session, now) {
+        return Math.min(session.expiresAt, session.createdAt + this.#ttlMs, (this.#activity.get(session.hash) ?? session.lastActiveAt) + this.#idleMs) > now;
+    }
+    /** Only explicit user actions call this. Polls, output, resize and ping/pong do not extend a login. */
+    touch(token, now = Date.now()) {
+        if (!this.verify(token, now))
+            return false;
+        const session = this.#find(token);
+        this.#activity.set(session.hash, now);
+        if (now - session.lastActiveAt >= TOUCH_WRITE_INTERVAL_MS) {
+            this.#store.update((draft) => {
+                const record = draft.sessions.find((candidate) => candidate.hash === session.hash);
+                if (record)
+                    record.lastActiveAt = now;
+            });
+        }
+        return true;
+    }
+    revoke(token) {
+        const hash = this.#hash(token);
+        if (!hash)
+            return;
+        this.#store.update((draft) => { draft.sessions = draft.sessions.filter((session) => session.hash !== hash); });
+        this.#notify(hash);
+    }
+    revokeAll() {
+        this.#store.update((draft) => { draft.sessions = []; });
+        this.#activity.clear();
+        for (const listener of this.#listeners)
+            listener(null);
+    }
+    onRevoked(token, listener) {
+        const hash = this.#hash(token);
+        const callback = (removed) => { if (removed === null || removed === hash)
+            listener(); };
+        this.#listeners.add(callback);
+        return () => { this.#listeners.delete(callback); };
+    }
+    #notify(hash) {
+        this.#activity.delete(hash);
+        for (const listener of this.#listeners)
+            listener(hash);
+    }
+}

package/runtime/server/src/modules/commit-message/commit-message-generator.js

@@ -0,0 +1,203 @@
+import { mkdtemp, readFile, rm } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { AppError } from "../../lib/errors.js";
+import { loadOccSettings } from "./occ-config.js";
+// Backends that can run without tools or with a read-only sandbox. OpenCode runs a full agent, so it is skipped.
+const RESTRICTED_BACKENDS = ['codex', 'claude'];
+const BACKEND_NAMES = { codex: 'Codex', opencode: 'OpenCode', claude: 'Claude' };
+// Prompt modules from OpenCodeCommit's defaults ("conventional oneliner" mode).
+const BASE_MODULE = `You are an expert at writing git commit messages.
+Analyze the code changes and generate a specific, descriptive commit message.
+
+Be specific about WHAT changed. Describe the actual functionality, file, or behavior affected.
+Never write vague messages like "update code", "make changes", or "update files".
+
+Respond with ONLY the commit message. No explanations, no code blocks, no markdown.`;
+const CONVENTIONAL_FORMAT = `Use conventional commit format: type(scope): description
+
+Choose the type that best matches the actual changes:
+- feat: new features or capabilities
+- fix: bug fixes, error corrections
+- docs: documentation, README, markdown, comments, JSDoc/rustdoc changes
+- style: formatting, whitespace, semicolons (no logic change)
+- refactor: code restructuring without behavior change
+- test: adding or modifying tests
+- perf: performance improvements
+- security: security fixes, vulnerability patches, auth hardening
+- revert: reverting previous changes
+- chore: build process, dependencies, tooling (only if nothing else fits)
+Scope: always include. Derive from the primary area affected (module, component, directory, or subsystem).
+Examples: feat(auth): add OAuth2 login flow | fix(parser): handle empty input gracefully | docs(api): update endpoint examples
+Use imperative mood. No period at end. Lowercase after colon.`;
+const ONELINER_LENGTH = 'Write exactly one line, no body. Maximum 72 characters.';
+const BACKEND_TIMEOUT_MS = 70_000;
+const MAX_OUTPUT_BYTES = 1024 * 1024;
+export function buildCommitPrompt({ branch, diff }) {
+    return [BASE_MODULE, CONVENTIONAL_FORMAT, ONELINER_LENGTH, 'Write the commit message in English.', `Branch: ${branch}`, '--- Git Diff ---', diff].join('\n\n');
+}
+/** Strip the wrapping models like to add: ANSI codes, preambles, code fences, quotes, emphasis. */
+export function sanitizeResponse(response) {
+    let result = response.trim();
+    // oxlint-disable-next-line no-control-regex
+    result = result.replace(/\x1b\[[0-9;]*m/g, '');
+    result = result
+        .replace(/^(?:(?:Here(?:'s| is)|Sure[,.].*?(?:here|is)|I(?:'ll| will|'m| am).*?:?)\s*(?:your |the |a )?(?:commit )?(?:message|response)?[:\s]*\n+)/i, '')
+        .trim();
+    result = result.replace(/^```(?:\w*)\n([\s\S]*?)\n```$/g, '$1').trim();
+    if (result.startsWith('`') && result.endsWith('`') && !result.includes('\n'))
+        result = result.slice(1, -1).trim();
+    if ((result.startsWith('"') && result.endsWith('"')) || (result.startsWith("'") && result.endsWith("'")))
+        result = result.slice(1, -1).trim();
+    if (result.startsWith('**') && result.endsWith('**'))
+        result = result.slice(2, -2).trim();
+    else if (result.startsWith('*') && result.endsWith('*'))
+        result = result.slice(1, -1).trim();
+    return result;
+}
+const TYPE_PATTERN = /^(feat|fix|docs|style|refactor|test|chore|perf|security|revert)(?:\(([^)]+)\))?:\s*(.+)/i;
+function inferType(message) {
+    const lower = message.toLowerCase();
+    if (/\b(readme|docs?|documentation|changelog|comment|jsdoc|rustdoc)\b/.test(lower))
+        return 'docs';
+    if (/\b(fix|bug|patch|resolve|issue|error|crash|repair)\b/.test(lower))
+        return 'fix';
+    if (/\b(add|implement|feature|new|introduce|support|create)\b/.test(lower))
+        return 'feat';
+    if (/\b(refactor|restructure|reorganize|rename|move|extract|simplify)\b/.test(lower))
+        return 'refactor';
+    if (/\b(tests?|spec|assert|coverage)\b/.test(lower))
+        return 'test';
+    if (/\b(style|format|whitespace|indent|lint|prettier|biome)\b/.test(lower))
+        return 'style';
+    if (/\b(perf|performance|optimiz|speed|faster|cache)\b/.test(lower))
+        return 'perf';
+    if (/\b(revert|undo|rollback)\b/.test(lower))
+        return 'revert';
+    if (/\b(security|vulnerab|auth|cve|xss|csrf|injection|sanitiz)\b/.test(lower))
+        return 'security';
+    return 'chore';
+}
+/** Normalize a model reply to `type(scope): description` on one line, lower-cased after the colon. */
+export function formatConventionalOneliner(response) {
+    const firstLine = sanitizeResponse(response).split('\n')[0]?.trim() ?? '';
+    const match = TYPE_PATTERN.exec(firstLine);
+    const type = match?.[1]?.toLowerCase() ?? inferType(firstLine);
+    const scope = match?.[2]?.trim();
+    let message = (match ? match[3] : firstLine)?.trim() || 'update code';
+    message = message.charAt(0).toLowerCase() + message.slice(1);
+    return `${type}${scope ? `(${scope})` : ''}: ${message}`.replace(/\s+/g, ' ').replace(/\.$/, '');
+}
+/** Text parts of `opencode run --format json`'s event stream. */
+export function parseOpenCodeJson(output) {
+    const texts = [];
+    for (const line of output.split('\n')) {
+        if (!line.trim())
+            continue;
+        let event;
+        try {
+            event = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        if (event.type === 'error')
+            throw new Error(`OpenCode: ${event.error?.data?.message ?? event.error?.name ?? 'unknown error'}`);
+        if (event.type === 'text' && event.part?.text)
+            texts.push(event.part.text);
+    }
+    return texts.join('');
+}
+/**
+ * Optional AI commit messages from the first restricted backend in OpenCodeCommit's backend-order
+ * (your first choice). Prompts go over stdin, never on a command line.
+ */
+export class CommitMessageGenerator {
+    #runner;
+    #logger;
+    #enabled;
+    #busy = false;
+    #loadSettings;
+    constructor(runner, logger, loadSettings = () => loadOccSettings(), enabled = false) {
+        this.#enabled = enabled;
+        this.#runner = runner;
+        this.#logger = logger;
+        this.#loadSettings = loadSettings;
+    }
+    async generate(context) {
+        if (!this.#enabled)
+            throw new AppError('FORBIDDEN', 'AI generation is disabled. The administrator must enable AI_COMMIT_ENABLED to send diffs to an AI CLI.');
+        if (this.#busy)
+            throw new AppError('TOO_MANY_REQUESTS', 'A commit message is already being generated. Try again shortly.');
+        this.#busy = true;
+        let backend;
+        try {
+            const settings = await this.#loadSettings();
+            backend = settings.backendOrder.find((candidate) => RESTRICTED_BACKENDS.includes(candidate));
+            if (!backend)
+                throw new AppError('GENERATION_FAILED', 'Add codex or claude to backend-order in the OpenCodeCommit config.');
+            const reply = await this.#run(backend, buildCommitPrompt(context), settings);
+            if (!sanitizeResponse(reply))
+                throw new Error('empty response');
+            return { message: formatConventionalOneliner(reply), backend };
+        }
+        catch (error) {
+            if (error instanceof AppError)
+                throw error;
+            // CLI errors can echo prompts, credentials or provider responses. Never expose them.
+            this.#logger.warn({ backend }, 'restricted commit message generation failed');
+            const name = backend ? BACKEND_NAMES[backend] : 'The AI CLI';
+            throw new AppError('GENERATION_FAILED', `${name} could not generate a message. Check its installation and authentication on the server.`);
+        }
+        finally {
+            this.#busy = false;
+        }
+    }
+    async #run(backend, prompt, settings) {
+        const cwd = await mkdtemp(path.join(os.tmpdir(), 'rw-commit-message-'));
+        try {
+            const outputFile = path.join(cwd, 'message.txt');
+            const argv = backend === 'codex' ? codexInvocation(settings, outputFile) : claudeInvocation(settings);
+            const result = await this.#runner.run(argv, { cwd, maxOutputBytes: MAX_OUTPUT_BYTES, timeoutMs: BACKEND_TIMEOUT_MS, input: prompt });
+            if (result.exitCode === 127)
+                throw new Error('not installed');
+            if (result.exitCode !== 0)
+                throw new Error(result.stderr.trim().split('\n').at(-1)?.slice(0, 200) || `exit code ${result.exitCode}`);
+            const stdout = result.stdout.toString('utf8');
+            // Codex prints progress on stdout; -o holds just the final reply.
+            if (backend === 'codex')
+                return await readFile(outputFile, 'utf8').catch(() => stdout);
+            return stdout;
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
+    }
+}
+function codexInvocation(settings, outputFile) {
+    return [
+        'codex', 'exec', '-',
+        // Read-only sandbox in an empty temp directory; no user config (its MCP servers and plugins), rules,
+        // web search, or saved session.
+        '--ephemeral', '--skip-git-repo-check', '--ignore-user-config', '--ignore-rules',
+        '-s', 'read-only', '--color', 'never', '--disable', 'plugins',
+        '-c', 'mcp_servers={}', '-c', 'web_search="disabled"',
+        // OpenCodeCommit's fast profile: no reasoning for the configured model, low for an unknown default.
+        '-c', `model_reasoning_effort="${settings.codexModel ? 'none' : 'low'}"`,
+        ...(settings.codexModel ? ['-m', settings.codexModel] : []),
+        ...(settings.codexProvider ? ['-c', `model_provider="${settings.codexProvider}"`] : []),
+        '-o', outputFile,
+    ];
+}
+function claudeInvocation(settings) {
+    return [
+        'claude', '-p',
+        // --bare authenticates only with an API key; without one, use the CLI's own login (keychain/OAuth).
+        // The flags below keep that mode just as restricted: no tools, MCP servers, settings, hooks or slash commands.
+        ...(process.env.ANTHROPIC_API_KEY ? ['--bare'] : []),
+        '--tools', '', '--strict-mcp-config', '--mcp-config', '{"mcpServers":{}}',
+        '--setting-sources', '', '--disallowedTools', '*', '--no-session-persistence', '--disable-slash-commands',
+        '--output-format', 'text', '--max-turns', '1',
+        ...(settings.claudeModel ? ['--model', settings.claudeModel] : []),
+    ];
+}

package/runtime/server/src/modules/commit-message/occ-config.js

@@ -0,0 +1,53 @@
+import { readFile } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+const BACKENDS = ['codex', 'opencode', 'claude'];
+export const DEFAULT_OCC_SETTINGS = {
+    backendOrder: ['codex', 'opencode', 'claude'],
+    claudeModel: '',
+    codexModel: '',
+    codexProvider: '',
+    opencodeModel: '',
+};
+const isBackend = (value) => BACKENDS.includes(value);
+/**
+ * Read the few top-level keys we share with OpenCodeCommit's config
+ * (~/.config/opencodecommit/config.toml, or $OPENCODECOMMIT_CONFIG): backend
+ * order and models. Only `key = "string"` and `key = [ "a", "b" ]` lines before
+ * the first table are understood; anything else is ignored.
+ */
+export function parseOccConfig(text) {
+    const values = new Map();
+    let order = null;
+    for (const raw of text.split('\n')) {
+        const line = raw.trim();
+        if (line.startsWith('['))
+            break;
+        const array = /^backend-order\s*=\s*\[(.*)\]$/.exec(line);
+        if (array) {
+            order = [...(array[1] ?? '').matchAll(/"([^"]*)"/g)].map((match) => match[1] ?? '').filter(isBackend);
+            continue;
+        }
+        const pair = /^([a-z-]+)\s*=\s*"([^"]*)"$/.exec(line);
+        if (pair?.[1])
+            values.set(pair[1], pair[2] ?? '');
+    }
+    const provider = values.get('provider') ?? '';
+    const model = values.get('model') ?? '';
+    return {
+        backendOrder: order && order.length > 0 ? order : DEFAULT_OCC_SETTINGS.backendOrder,
+        claudeModel: values.get('claude-model') ?? '',
+        codexModel: values.get('codex-model') ?? '',
+        codexProvider: values.get('codex-provider') ?? '',
+        opencodeModel: provider && model ? `${provider}/${model}` : '',
+    };
+}
+export async function loadOccSettings(env = process.env) {
+    const file = env.OPENCODECOMMIT_CONFIG || path.join(env.XDG_CONFIG_HOME || path.join(os.homedir(), '.config'), 'opencodecommit', 'config.toml');
+    try {
+        return parseOccConfig(await readFile(file, 'utf8'));
+    }
+    catch {
+        return DEFAULT_OCC_SETTINGS;
+    }
+}