@fitlab-ai/agent-infra 0.8.3 → 0.8.5

package/dist/lib/sandbox/tools.js

@@ -44,8 +44,8 @@ function createBuiltinTools(home, project) {
             // codex churns ~/.codex/logs_2.sqlite heavily (upstream openai/codex#24275);
             // a bind-mount would write-amplify onto the host SSD via virtiofs. Mount the
             // codex home as tmpfs so those logs stay in RAM and die with the container.
-            // Only the seeded config (config.toml, model-catalogs) is bound back over
-            // the tmpfs; runtime files like logs_2.sqlite must stay in RAM.
+            // Seeded config (config.toml, model-catalogs) is copied into the tmpfs at
+            // startup; runtime files like logs_2.sqlite stay in RAM.
             tmpfs: { size: '512m', seed: ['config.toml', 'model-catalogs'] },
             hostLiveMounts: [
                 { hostPath: hostJoin(home, '.codex', 'auth.json'), containerSubpath: 'auth.json' }

package/dist/lib/server/daemon.js

@@ -8,6 +8,7 @@ import { runAi } from './runner.js';
 import { streamCommand } from './streamer.js';
 import { markdownMessage, replyOutbound, textMessage } from './display.js';
 import { buildStatusModel, statusModelToDisplay } from '../task/commands/status.js';
+import { getProcessStartTime, removePidRecordIfMatches } from './process-state.js';
 function errorMessage(error) {
     return error instanceof Error ? error.message : String(error);
 }
@@ -85,6 +86,7 @@ export async function runDaemon() {
     }
     const logger = createLogger(config.log);
     logger.info(`daemon starting agent-infra ${VERSION} pid=${process.pid}`);
+    const ownStartTime = getProcessStartTime(process.pid);
     const abortController = new AbortController();
     let resolveShutdown = () => { };
     const shutdown = new Promise((resolve) => {
@@ -106,6 +108,13 @@ export async function runDaemon() {
             await unloadAdapters(adapters);
             clearInterval(heartbeat);
             logger.close();
+            if (ownStartTime !== null) {
+                removePidRecordIfMatches(config.pidFile, {
+                    version: 1,
+                    pid: process.pid,
+                    startTime: ownStartTime
+                });
+            }
             resolveShutdown();
         })();
     };

package/dist/lib/server/process-control.js

@@ -1,66 +1,44 @@
 import fs from 'node:fs';
-import path from 'node:path';
 import { spawn, execFileSync } from 'node:child_process';
 import { loadServerConfig } from './config.js';
 import { runDaemon } from './daemon.js';
+import { getProcessStartTime, isProcessAlive, processIdentityMatches, readProcessState, removePidFileIfMatches, writePidRecord } from './process-state.js';
+export { isProcessAlive } from './process-state.js';
 export function buildStopCommand(pid, platform) {
     if (platform === 'win32') {
         return { kind: 'exec', command: 'taskkill', args: ['/PID', String(pid), '/T', '/F'] };
     }
     return { kind: 'signal', signal: 'SIGTERM' };
 }
-// Liveness check that treats an exited-but-unreaped daemon as dead.
-//
-// The daemon is spawned detached and re-parented to init when `ai server start`
-// exits. After it terminates, `process.kill(pid, 0)` still succeeds until init
-// reaps the zombie. On Linux we therefore also check /proc state so status/stop
-// /start don't treat an already-exited daemon as running. macOS reaps orphans
-// via launchd and Windows has no zombies, so the kill(pid, 0) result is enough.
-export function isProcessAlive(pid) {
-    try {
-        process.kill(pid, 0);
-    }
-    catch (error) {
-        // EPERM means the process exists but we may not signal it → still alive.
-        return error.code === 'EPERM';
-    }
-    if (process.platform === 'linux') {
-        try {
-            const stat = fs.readFileSync(`/proc/${pid}/stat`, 'utf8');
-            // The process state is the first token after the parenthesised comm.
-            const state = stat.slice(stat.lastIndexOf(')') + 1).trim().charAt(0);
-            if (state === 'Z')
-                return false;
-        }
-        catch {
-            return false; // /proc entry vanished → not alive
-        }
-    }
-    return true;
+function delay(ms) {
+    return new Promise((resolve) => {
+        setTimeout(resolve, ms);
+    });
 }
-function readPid(pidFile) {
-    try {
-        const raw = fs.readFileSync(pidFile, 'utf8').trim();
-        const pid = Number.parseInt(raw, 10);
-        return Number.isInteger(pid) && pid > 0 ? pid : null;
-    }
-    catch {
-        return null;
-    }
+async function waitForProcessIdentity(pid, timeoutMs = 2000) {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        const startTime = getProcessStartTime(pid);
+        if (startTime !== null)
+            return { version: 1, pid, startTime };
+        await delay(25);
+    }
+    return null;
 }
-function removePidFile(pidFile) {
+function terminateIfMatching(record) {
+    if (!processIdentityMatches(record))
+        return;
+    const command = buildStopCommand(record.pid, process.platform);
     try {
-        fs.unlinkSync(pidFile);
+        if (command.kind === 'exec')
+            execFileSync(command.command, command.args);
+        else
+            process.kill(record.pid, command.signal);
     }
     catch {
-        // Already gone.
+        // Best effort cleanup for a daemon whose PID record could not be published.
     }
 }
-function delay(ms) {
-    return new Promise((resolve) => {
-        setTimeout(resolve, ms);
-    });
-}
 function enabledAdapterNames(config) {
     return Object.entries(config.adapters)
         .filter(([, adapter]) => adapter?.enabled === true)
@@ -69,15 +47,13 @@ function enabledAdapterNames(config) {
 export async function start({ foreground = false } = {}) {
     const config = loadServerConfig();
     const pidPath = config.pidFile;
-    // Zombie PID cleanup: a stale PID file from a crashed daemon must not block a
-    // fresh start.
-    const existing = readPid(pidPath);
-    if (existing !== null && isProcessAlive(existing)) {
-        process.stdout.write(`server already running (pid ${existing})\n`);
+    const existing = readProcessState(pidPath);
+    if (existing.kind === 'running') {
+        process.stdout.write(`server already running (pid ${existing.record.pid})\n`);
         return;
     }
-    if (existing !== null) {
-        removePidFile(pidPath);
+    if (existing.kind !== 'missing') {
+        removePidFileIfMatches(pidPath, existing.snapshot);
     }
     if (foreground) {
         await runDaemon();
@@ -98,47 +74,64 @@ export async function start({ foreground = false } = {}) {
     if (typeof child.pid !== 'number') {
         throw new Error('server: failed to spawn daemon process');
     }
-    fs.mkdirSync(path.dirname(pidPath), { recursive: true });
-    fs.writeFileSync(pidPath, `${child.pid}\n`);
-    process.stdout.write(`server started (pid ${child.pid})\n`);
+    // The initial check, spawn, and record publication are not a mutually
+    // exclusive transaction. Atomic publication keeps the record complete, but
+    // a separate locking design is required to serialize concurrent starts.
+    const record = await waitForProcessIdentity(child.pid);
+    if (record === null || !processIdentityMatches(record)) {
+        throw new Error('server: unable to verify spawned daemon process identity');
+    }
+    try {
+        writePidRecord(pidPath, record);
+    }
+    catch (error) {
+        terminateIfMatching(record);
+        throw error;
+    }
+    process.stdout.write(`server started (pid ${record.pid})\n`);
 }
 export async function stop() {
     const config = loadServerConfig();
-    const pid = readPid(config.pidFile);
-    if (pid === null) {
+    const state = readProcessState(config.pidFile);
+    if (state.kind === 'missing') {
         process.stdout.write('server is not running (no pid file)\n');
         return;
     }
-    if (!isProcessAlive(pid)) {
-        removePidFile(config.pidFile);
+    if (state.kind !== 'running') {
+        removePidFileIfMatches(config.pidFile, state.snapshot);
         process.stdout.write('server is not running (removed stale pid file)\n');
         return;
     }
-    const command = buildStopCommand(pid, process.platform);
+    const { record } = state;
+    if (!processIdentityMatches(record)) {
+        removePidFileIfMatches(config.pidFile, state.snapshot);
+        process.stdout.write('server is not running (removed stale pid file)\n');
+        return;
+    }
+    const command = buildStopCommand(record.pid, process.platform);
     if (command.kind === 'exec') {
         execFileSync(command.command, command.args);
     }
     else {
-        process.kill(pid, command.signal);
+        process.kill(record.pid, command.signal);
         const deadline = Date.now() + 5000;
-        while (isProcessAlive(pid) && Date.now() < deadline) {
+        while (isProcessAlive(record.pid) && Date.now() < deadline) {
             await delay(100);
         }
-        if (isProcessAlive(pid)) {
-            process.kill(pid, 'SIGKILL');
+        if (isProcessAlive(record.pid) && processIdentityMatches(record)) {
+            process.kill(record.pid, 'SIGKILL');
         }
     }
-    removePidFile(config.pidFile);
-    process.stdout.write(`server stopped (pid ${pid})\n`);
+    removePidFileIfMatches(config.pidFile, state.snapshot);
+    process.stdout.write(`server stopped (pid ${record.pid})\n`);
 }
 export function status() {
     const config = loadServerConfig();
-    const pid = readPid(config.pidFile);
-    if (pid === null || !isProcessAlive(pid)) {
+    const state = readProcessState(config.pidFile);
+    if (state.kind !== 'running') {
+        if (state.kind !== 'missing')
+            removePidFileIfMatches(config.pidFile, state.snapshot);
         process.stdout.write('server: stopped\n');
-        if (pid !== null) {
-            process.stdout.write(`  (stale pid file references pid ${pid})\n`);
-        }
         return;
     }
     let startedAt = 'unknown';
@@ -150,7 +143,7 @@ export function status() {
     }
     const adapters = enabledAdapterNames(config);
     process.stdout.write(`server: running\n` +
-        `  pid: ${pid}\n` +
+        `  pid: ${state.record.pid}\n` +
         `  started: ${startedAt}\n` +
         `  adapters: ${adapters.length > 0 ? adapters.join(', ') : '(none)'}\n` +
         `  pid file: ${config.pidFile}\n` +

package/dist/lib/server/process-state.js

@@ -0,0 +1,168 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { execFileSync } from 'node:child_process';
+export function parseLinuxProcessStat(raw) {
+    const closeParen = raw.lastIndexOf(')');
+    if (closeParen < 0)
+        return null;
+    const fields = raw.slice(closeParen + 1).trim().split(/\s+/);
+    const state = fields[0];
+    const startTime = fields[19];
+    if (typeof state !== 'string' || state.length !== 1 || !/^\d+$/.test(startTime ?? '')) {
+        return null;
+    }
+    return { state, startTime: startTime };
+}
+export function buildProcessStartTimeQuery(pid, platform) {
+    if (platform === 'darwin') {
+        return { command: 'ps', args: ['-p', String(pid), '-o', 'lstart='] };
+    }
+    if (platform === 'win32') {
+        const script = `$process = Get-CimInstance Win32_Process -Filter 'ProcessId = ${pid}'; ` +
+            `if ($null -ne $process) { $process.CreationDate.ToUniversalTime().ToString('o') }`;
+        return {
+            command: 'powershell.exe',
+            args: ['-NoProfile', '-NonInteractive', '-Command', script]
+        };
+    }
+    return null;
+}
+export function isProcessAlive(pid, platform = process.platform) {
+    if (!Number.isInteger(pid) || pid <= 0)
+        return false;
+    if (platform === 'linux') {
+        try {
+            const stat = parseLinuxProcessStat(fs.readFileSync(`/proc/${pid}/stat`, 'utf8'));
+            return stat !== null && stat.state !== 'Z';
+        }
+        catch {
+            return false;
+        }
+    }
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        return error.code === 'EPERM';
+    }
+}
+export function getProcessStartTime(pid, platform = process.platform) {
+    if (!Number.isInteger(pid) || pid <= 0)
+        return null;
+    if (platform === 'linux') {
+        try {
+            const stat = parseLinuxProcessStat(fs.readFileSync(`/proc/${pid}/stat`, 'utf8'));
+            return stat !== null && stat.state !== 'Z' ? stat.startTime : null;
+        }
+        catch {
+            return null;
+        }
+    }
+    if (!isProcessAlive(pid, platform))
+        return null;
+    const query = buildProcessStartTimeQuery(pid, platform);
+    if (query === null)
+        return null;
+    try {
+        const output = execFileSync(query.command, query.args, { encoding: 'utf8' }).trim();
+        if (output.length === 0)
+            return null;
+        if (platform === 'win32') {
+            const timestamp = new Date(output);
+            return Number.isNaN(timestamp.getTime()) ? null : timestamp.toISOString();
+        }
+        return output;
+    }
+    catch {
+        return null;
+    }
+}
+function parsePidRecord(raw) {
+    const trimmed = raw.trim();
+    if (/^[1-9]\d*$/.test(trimmed)) {
+        const pid = Number(trimmed);
+        return Number.isSafeInteger(pid) ? { kind: 'legacy', pid } : { kind: 'invalid' };
+    }
+    try {
+        const value = JSON.parse(trimmed);
+        if (value !== null &&
+            value.version === 1 &&
+            Number.isSafeInteger(value.pid) &&
+            (value.pid ?? 0) > 0 &&
+            typeof value.startTime === 'string' &&
+            value.startTime.length > 0) {
+            return {
+                kind: 'record',
+                record: { version: 1, pid: value.pid, startTime: value.startTime }
+            };
+        }
+    }
+    catch {
+        // Invalid JSON is an invalid PID record.
+    }
+    return { kind: 'invalid' };
+}
+export function readProcessState(pidFile) {
+    let snapshot;
+    try {
+        snapshot = fs.readFileSync(pidFile, 'utf8');
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return { kind: 'missing', snapshot: null };
+        return { kind: 'invalid', snapshot: '' };
+    }
+    const parsed = parsePidRecord(snapshot);
+    if (parsed.kind === 'invalid')
+        return { kind: 'invalid', snapshot };
+    if (parsed.kind === 'legacy')
+        return { kind: 'legacy', snapshot, pid: parsed.pid };
+    const currentStartTime = getProcessStartTime(parsed.record.pid);
+    if (currentStartTime === null || currentStartTime !== parsed.record.startTime) {
+        return { kind: 'stale', snapshot, record: parsed.record };
+    }
+    return { kind: 'running', snapshot, record: parsed.record };
+}
+export function writePidRecord(pidFile, record) {
+    fs.mkdirSync(path.dirname(pidFile), { recursive: true });
+    const temporary = `${pidFile}.${process.pid}.${Math.random().toString(16).slice(2)}.tmp`;
+    try {
+        fs.writeFileSync(temporary, `${JSON.stringify(record)}\n`);
+        fs.renameSync(temporary, pidFile);
+    }
+    catch (error) {
+        try {
+            fs.unlinkSync(temporary);
+        }
+        catch {
+            // The temporary file was never created or was already renamed.
+        }
+        throw error;
+    }
+}
+export function removePidFileIfMatches(pidFile, expectedSnapshot) {
+    if (expectedSnapshot === null)
+        return false;
+    try {
+        if (fs.readFileSync(pidFile, 'utf8') !== expectedSnapshot)
+            return false;
+        fs.unlinkSync(pidFile);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function removePidRecordIfMatches(pidFile, expected) {
+    const state = readProcessState(pidFile);
+    if (state.kind !== 'running')
+        return false;
+    if (state.record.pid !== expected.pid || state.record.startTime !== expected.startTime)
+        return false;
+    return removePidFileIfMatches(pidFile, state.snapshot);
+}
+export function processIdentityMatches(record) {
+    return getProcessStartTime(record.pid) === record.startTime;
+}
+//# sourceMappingURL=process-state.js.map

package/dist/lib/update.js

@@ -145,6 +145,8 @@ async function cmdUpdate() {
     // update skill
     copySkillDir(path.join(templateDir, '.agents', 'skills', 'update-agent-infra'), path.join('.agents', 'skills', 'update-agent-infra'), replacements, language, platformType);
     ok('Updated .agents/skills/update-agent-infra/');
+    renderFile(path.join(templateDir, '.agents', 'scripts', 'lib', 'agent-infra-package.js'), path.join('.agents', 'scripts', 'lib', 'agent-infra-package.js'), replacements);
+    ok('Updated .agents/scripts/lib/agent-infra-package.js');
     try {
         fs.unlinkSync(path.join('.agents', 'skills', 'update-agent-infra', 'scripts', 'sync-templates.cjs'));
     }

package/lib/cp.ts

@@ -5,8 +5,9 @@ import { platform as currentPlatform, tmpdir as defaultTmpdir } from 'node:os';
 import path from 'node:path';
 import { parseArgs } from 'node:util';
 import { createClipboardAdapter, type ClipboardAdapter } from './sandbox/clipboard/index.ts';
+import { RECEIVER_CAPABILITY, receiveRemoteClipboardPng } from './sandbox/clipboard/inbox.ts';
 
-const USAGE = 'Usage: ai cp <ssh-alias>\n\nCopy the local clipboard image (PNG) to a remote macOS NSPasteboard over ssh/scp.\n';
+const USAGE = 'Usage: ai cp <ssh-alias>\n\nCopy the local clipboard image (PNG) to a remote macOS clipboard or Linux sandbox over SSH.\n';
 const COMMAND_TIMEOUT_MS = 30_000;
 
 export type SpawnResult = {
@@ -65,6 +66,21 @@ export async function cmdCp(args: string[], deps: CpDeps = {}): Promise<number>
     writeStderr = (chunk: string) => process.stderr.write(chunk)
   } = deps;
 
+  if (args.length === 1 && args[0] === '--remote-receive-capability') {
+    if (platform === 'linux') writeStdout(`${RECEIVER_CAPABILITY}\n`);
+    return platform === 'linux' ? 0 : 1;
+  }
+  if (args.length === 2 && args[0] === '--remote-receive-v1') {
+    try {
+      const result = receiveRemoteClipboardPng(process.env.HOME || process.env.USERPROFILE || '', args[1]!, platform);
+      writeStdout(`${result}\n`);
+      return 0;
+    } catch (error) {
+      writeStderr(`${error instanceof Error ? error.message : 'clipboard receive failed'}\n`);
+      return 1;
+    }
+  }
+
   if (args[0] === '--help' || args[0] === '-h' || args[0] === 'help') {
     writeStdout(USAGE);
     return 0;
@@ -110,6 +126,35 @@ export async function cmdCp(args: string[], deps: CpDeps = {}): Promise<number>
     writeFileFn(localPng, png);
 
     remotePath = `/tmp/agent-infra-cp-${randomId()}.png`;
+    const remoteSystem = spawnFn('ssh', [
+      '-o', 'BatchMode=yes', '-o', 'ConnectTimeout=10', alias, 'uname', '-s'
+    ]);
+    if (remoteSystem.status !== 0) {
+      writeStderr(`failed to detect remote platform on ${alias}:\n${commandDetail(remoteSystem)}\n`);
+      return 1;
+    }
+    const remotePlatform = remoteSystem.stdout.trim();
+    if (remotePlatform !== 'Darwin' && remotePlatform !== 'Linux') {
+      writeStderr(`unsupported remote platform on ${alias}: ${remotePlatform || 'unknown'}\n`);
+      return 1;
+    }
+    if (remotePlatform === 'Linux') {
+      const homeCheck = spawnFn('ssh', [
+        '-o', 'BatchMode=yes', '-o', 'ConnectTimeout=10', alias, 'test', '-d', '$HOME/.agent-infra'
+      ]);
+      if (homeCheck.status !== 0) {
+        writeStderr(`remote agent-infra installation is missing on ${alias}\n`);
+        return 1;
+      }
+      const capability = spawnFn('ssh', [
+        '-o', 'BatchMode=yes', '-o', 'ConnectTimeout=10', alias, 'ai', 'cp', '--remote-receive-capability'
+      ]);
+      if (capability.status !== 0 || capability.stderr !== '' || capability.stdout.replace(/\n$/u, '') !== RECEIVER_CAPABILITY) {
+        writeStderr(`remote agent-infra clipboard receiver is unavailable or incompatible on ${alias}; update agent-infra\n`);
+        return 1;
+      }
+    }
+
     const upload = spawnFn('scp', [
       '-o',
       'BatchMode=yes',
@@ -124,25 +169,21 @@ export async function cmdCp(args: string[], deps: CpDeps = {}): Promise<number>
     }
     uploaded = true;
 
-    // Remote write currently targets macOS only: it pipes an AppleScript to the
-    // remote `osascript` to set its NSPasteboard. This is the extension point for
-    // other remote platforms later (e.g. dispatch on remote OS to wl-copy/xclip
-    // on Linux); a non-macOS remote fails here with a clear non-zero error today.
-    const setRemote = spawnFn('ssh', [
-      '-o',
-      'BatchMode=yes',
-      '-o',
-      'ConnectTimeout=10',
-      alias,
-      'osascript',
-      '-'
-    ], remoteSetScript(remotePath));
+    const setRemote = remotePlatform === 'Darwin'
+      ? spawnFn('ssh', [
+        '-o', 'BatchMode=yes', '-o', 'ConnectTimeout=10', alias, 'osascript', '-'
+      ], remoteSetScript(remotePath))
+      : spawnFn('ssh', [
+        '-o', 'BatchMode=yes', '-o', 'ConnectTimeout=10', alias, 'ai', 'cp', '--remote-receive-v1', remotePath
+      ]);
     if (setRemote.status !== 0) {
       writeStderr(`failed to set remote clipboard on ${alias}:\n${commandDetail(setRemote)}\n`);
       return 1;
     }
 
-    writeStdout(`copied clipboard image to ${alias}\n`);
+    writeStdout(remotePlatform === 'Linux'
+      ? `uploaded clipboard image to ${alias}; return to the SSH session and press Ctrl+V\n`
+      : `copied clipboard image to ${alias}\n`);
     return 0;
   } finally {
     if (uploaded && remotePath) {

package/lib/defaults.json

@@ -44,14 +44,23 @@
       ".gemini/commands/",
       ".git-hooks/check-version-format.sh",
       ".github/scripts/",
+      ".github/workflows/metadata-sync.yml",
+      ".github/workflows/pr-label.yml",
+      ".github/workflows/status-label.yml",
       ".opencode/commands/"
     ],
+    "guardedManaged": [
+      ".github/workflows/metadata-sync.yml",
+      ".github/workflows/pr-label.yml",
+      ".github/workflows/status-label.yml"
+    ],
     "merged": [
       "**/post-release.*",
       "**/release.*",
       "**/test-integration.*",
       "**/test.*",
       "**/upgrade-dependency.*",
+      ".agents/rules/testing-discipline.*",
       ".agents/skills/post-release/SKILL.*",
       ".agents/skills/release/SKILL.*",
       ".agents/skills/test-integration/SKILL.*",

package/lib/init.ts

@@ -278,6 +278,12 @@ async function cmdInit(): Promise<void> {
     platformType
   );
   ok('Installed .agents/skills/update-agent-infra/');
+  renderFile(
+    path.join(templateDir, '.agents', 'scripts', 'lib', 'agent-infra-package.js'),
+    path.join('.agents', 'scripts', 'lib', 'agent-infra-package.js'),
+    replacements
+  );
+  ok('Installed .agents/scripts/lib/agent-infra-package.js');
 
   // install Claude command (only if enabled)
   if (enabledTUISet.has('claude-code')) {
@@ -347,6 +353,9 @@ async function cmdInit(): Promise<void> {
   console.log('');
   ok('Project initialized successfully!');
   console.log('');
+  console.log('  If this init used npx, install agent-infra persistently before update or validation:');
+  console.log('    npm install -g @fitlab-ai/agent-infra');
+  console.log('');
   if (enabledTUISet.size === 0) {
     console.log('  No built-in TUI selected.');
     console.log(`  Configure "customTUIs" in ${configPath} before running update-agent-infra.`);

package/lib/sandbox/capture.ts

@@ -2,6 +2,7 @@ import { spawn } from 'node:child_process';
 import { loadConfig } from './config.ts';
 import { containerNameCandidates, sandboxBranchLabel, sandboxLabel } from './constants.ts';
 import { detectEngine } from './engine.ts';
+import { commandForEngine } from './shell.ts';
 import { hostTimezoneEnvFlags, terminalEnvFlags } from './commands/enter.ts';
 import {
   fetchSandboxRows,
@@ -95,12 +96,12 @@ function buildRunScript(params: {
   return `#!/bin/sh
 set -u
 cd /workspace
-date "+%Y-%m-%d %H:%M:%S%:z" > ${runDir}/started_at
+date "+%Y-%m-%d %H:%M:%S%z" | sed 's/\\([+-][0-9][0-9]\\)\\([0-9][0-9]\\)$/\\1:\\2/' > ${runDir}/started_at
 printf '%s\\n' running > ${runDir}/status
 ${command}
 code=$?
 printf '%s\\n' "$code" > ${runDir}/exit_code
-date "+%Y-%m-%d %H:%M:%S%:z" > ${runDir}/finished_at
+date "+%Y-%m-%d %H:%M:%S%z" | sed 's/\\([+-][0-9][0-9]\\)\\([0-9][0-9]\\)$/\\1:\\2/' > ${runDir}/finished_at
 if [ "$code" -eq 0 ]; then
   printf '%s\\n' completed > ${runDir}/status
 else
@@ -202,7 +203,8 @@ export async function runInSandbox(
     '-lc',
     buildTmuxLauncher({ request, runId })
   ];
-  const result = await (options.spawn ?? spawnCapture)('docker', dockerArgs);
+  const command = commandForEngine(engine, 'docker', dockerArgs);
+  const result = await (options.spawn ?? spawnCapture)(command.cmd, command.args);
   return {
     ...result,
     run: {