@kbediako/codex-orchestrator 0.1.38 → 0.2.1

package/dist/orchestrator/src/cli/run/workspacePath.js

@@ -0,0 +1,101 @@
+import { execFile } from 'node:child_process';
+import { access, lstat, mkdir, rename, rm } from 'node:fs/promises';
+import { isAbsolute, join, relative, resolve } from 'node:path';
+import { promisify } from 'node:util';
+export const PROVIDER_WORKSPACE_ROOT_DIRNAME = '.workspaces';
+const execFileAsync = promisify(execFile);
+export function normalizeWorkspacePath(value) {
+    if (typeof value !== 'string') {
+        return null;
+    }
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : null;
+}
+export function resolveProviderWorkspacePath(repoRoot, taskId) {
+    const workspacePath = resolve(repoRoot, PROVIDER_WORKSPACE_ROOT_DIRNAME, taskId);
+    if (!isProviderWorkspacePathWithinRoot(repoRoot, workspacePath)) {
+        throw new Error(`Invalid provider workspace task id: ${taskId}`);
+    }
+    return workspacePath;
+}
+export function resolveExplicitProviderWorkspacePathWithinRoot(repoRoot, taskId, manifestRecord) {
+    const explicitWorkspacePath = resolveManifestWorkspacePath(manifestRecord);
+    if (!explicitWorkspacePath || !isProviderWorkspacePathWithinRoot(repoRoot, explicitWorkspacePath)) {
+        return null;
+    }
+    const resolvedWorkspacePath = resolve(explicitWorkspacePath);
+    return resolvedWorkspacePath === resolveProviderWorkspacePath(repoRoot, taskId)
+        ? resolvedWorkspacePath
+        : null;
+}
+export async function ensureProviderWorkspace(repoRoot, taskId) {
+    const workspacePath = resolveProviderWorkspacePath(repoRoot, taskId);
+    if (await isUsableProviderWorkspace(workspacePath)) {
+        return workspacePath;
+    }
+    await rm(workspacePath, { recursive: true, force: true });
+    await mkdir(join(repoRoot, PROVIDER_WORKSPACE_ROOT_DIRNAME), { recursive: true });
+    await execFileAsync('git', ['-C', repoRoot, 'worktree', 'prune', '--expire', 'now']);
+    await execFileAsync('git', ['-C', repoRoot, 'worktree', 'add', '--detach', workspacePath, 'HEAD']);
+    return workspacePath;
+}
+export async function resolveProviderResumeWorkspacePath(repoRoot, taskId, manifestRecord) {
+    const explicitWorkspacePath = resolveExplicitProviderWorkspacePathWithinRoot(repoRoot, taskId, manifestRecord);
+    if (explicitWorkspacePath &&
+        (await isUsableProviderWorkspace(explicitWorkspacePath))) {
+        return explicitWorkspacePath;
+    }
+    return ensureProviderWorkspace(repoRoot, taskId);
+}
+export async function cleanupProviderWorkspace(repoRoot, workspacePath, options = {}) {
+    if (!isProviderWorkspacePathWithinRoot(repoRoot, workspacePath)) {
+        return false;
+    }
+    const resolvedWorkspacePath = resolve(workspacePath);
+    const quarantinedWorkspacePath = `${resolvedWorkspacePath}.removing-${process.pid}-${Date.now()}`;
+    options.beforeRemove?.();
+    try {
+        await rename(resolvedWorkspacePath, quarantinedWorkspacePath);
+    }
+    catch (error) {
+        if (error.code !== 'ENOENT') {
+            throw error;
+        }
+        await execFileAsync('git', ['-C', repoRoot, 'worktree', 'prune', '--expire', 'now']).catch(() => undefined);
+        return true;
+    }
+    await options.afterQuarantine?.(quarantinedWorkspacePath);
+    await rm(quarantinedWorkspacePath, { recursive: true, force: true });
+    await execFileAsync('git', ['-C', repoRoot, 'worktree', 'prune', '--expire', 'now']).catch(() => undefined);
+    return true;
+}
+export function resolveLegacyWorkspacePathFromRunDir(runDir) {
+    return resolve(runDir, '..', '..', '..', '..');
+}
+export function resolveManifestWorkspacePath(manifestRecord, runDir = null) {
+    const explicitWorkspacePath = normalizeWorkspacePath(manifestRecord.workspace_path) ??
+        normalizeWorkspacePath(manifestRecord.workspacePath);
+    if (explicitWorkspacePath) {
+        return explicitWorkspacePath;
+    }
+    return runDir ? resolveLegacyWorkspacePathFromRunDir(runDir) : null;
+}
+async function isUsableProviderWorkspace(workspacePath) {
+    try {
+        const stats = await lstat(workspacePath);
+        if (!stats.isDirectory()) {
+            return false;
+        }
+        await access(join(workspacePath, '.git'));
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function isProviderWorkspacePathWithinRoot(repoRoot, workspacePath) {
+    const workspaceRoot = resolve(repoRoot, PROVIDER_WORKSPACE_ROOT_DIRNAME);
+    const candidatePath = resolve(workspacePath);
+    const relativePath = relative(workspaceRoot, candidatePath);
+    return relativePath !== '' && !relativePath.startsWith('..') && !isAbsolute(relativePath);
+}

package/dist/orchestrator/src/cli/runtime/mode.js

@@ -26,7 +26,8 @@ export function resolveRuntimeMode(options = {}) {
         };
     }
     const envKey = options.envKey ?? DEFAULT_RUNTIME_MODE_ENV_KEY;
-    const envValue = options.env?.[envKey] ?? process.env[envKey];
+    const env = options.env ?? process.env;
+    const envValue = env[envKey];
     if (typeof envValue === 'string' && envValue.trim().length > 0) {
         return {
             mode: parseRuntimeModeFromSource(envValue, `env ${envKey}`),

package/dist/orchestrator/src/cli/runtime/provider.js

@@ -1,3 +1,4 @@
+import { existsSync } from 'node:fs';
 import { execFile } from 'node:child_process';
 import { promisify } from 'node:util';
 import { resolveCodexCliBin } from '../utils/codexCli.js';
@@ -48,6 +49,24 @@ function summarizePreflightFailures(issues) {
     const messages = issues.map((issue) => issue.message).join(' ');
     return `Appserver preflight failed (${codes}). ${messages}`.trim();
 }
+function buildCodexCommandUnavailableIssue(codexBin) {
+    return {
+        code: 'codex-command-unavailable',
+        message: `Could not resolve the Codex CLI executable (${codexBin}) under the current runtime.`
+    };
+}
+function buildRuntimeWorkspaceUnavailableIssue(repoRoot) {
+    return {
+        code: 'runtime-workspace-unavailable',
+        message: `Could not probe the Codex runtime because the selected repo root is unavailable (${repoRoot}).`
+    };
+}
+function buildEnoentProbeIssue(params) {
+    if (!existsSync(params.repoRoot)) {
+        return buildRuntimeWorkspaceUnavailableIssue(params.repoRoot);
+    }
+    return buildCodexCommandUnavailableIssue(params.codexBin);
+}
 function resolveRequestedMode(options) {
     if (options.executionMode === 'cloud' &&
         options.requestedMode === 'appserver' &&
@@ -99,6 +118,16 @@ async function runAppserverPreflight(params) {
     }
     const appServerHelp = await runCodexProbe(codexBin, ['app-server', '--help'], params.repoRoot, params.env, APP_SERVER_HELP_TIMEOUT_MS);
     if (!appServerHelp.ok) {
+        if (appServerHelp.code === 'ENOENT') {
+            issues.push(buildEnoentProbeIssue({
+                codexBin,
+                repoRoot: params.repoRoot
+            }));
+            return {
+                ok: false,
+                issues
+            };
+        }
         issues.push({
             code: 'appserver-command-unavailable',
             message: appServerHelp.code === 'timeout'
@@ -109,11 +138,19 @@ async function runAppserverPreflight(params) {
     if (!envFlagEnabled(params.env.CODEX_ORCHESTRATOR_APPSERVER_SKIP_LOGIN_CHECK)) {
         const loginStatus = await runCodexProbe(codexBin, ['login', 'status'], params.repoRoot, params.env, LOGIN_STATUS_TIMEOUT_MS);
         if (!loginStatus.ok) {
+            const enoentIssue = loginStatus.code === 'ENOENT'
+                ? buildEnoentProbeIssue({
+                    codexBin,
+                    repoRoot: params.repoRoot
+                })
+                : null;
             issues.push({
-                code: 'login-status-failed',
+                code: enoentIssue?.code ?? 'login-status-failed',
                 message: loginStatus.code === 'timeout'
                     ? 'Timed out probing `codex login status`.'
-                    : 'Failed probing `codex login status`.'
+                    : loginStatus.code === 'ENOENT'
+                        ? (enoentIssue?.message ?? 'Failed probing `codex login status`.')
+                        : 'Failed probing `codex login status`.'
             });
         }
         else {

package/dist/orchestrator/src/cli/selfCheckCliShell.js

@@ -0,0 +1,12 @@
+export async function runSelfCheckCliShell(params) {
+    const result = params.buildResult();
+    if (params.format === 'json') {
+        params.log(JSON.stringify(result, null, 2));
+        return;
+    }
+    params.log(`Status: ${result.status}`);
+    params.log(`Name: ${result.name}`);
+    params.log(`Version: ${result.version}`);
+    params.log(`Node: ${result.node}`);
+    params.log(`Timestamp: ${result.timestamp}`);
+}