@chrysb/alphaclaw 0.9.27 → 0.9.29

package/lib/server/doctor/service.js

@@ -1,3 +1,4 @@
+const crypto = require("crypto");
 const fs = require("fs");
 const path = require("path");
 const {
@@ -5,9 +6,11 @@ const {
   buildBootstrapTruncationCards,
 } = require("./bootstrap-context");
 const { buildDoctorPrompt } = require("./prompt");
+const { hashDoctorFixToken } = require("./fix-completion");
 const { normalizeDoctorResult } = require("./normalize");
 const { calculateWorkspaceDelta, computeWorkspaceSnapshot } = require("./workspace-fingerprint");
 const {
+  kDoctorCardStatus,
   kDoctorEngine,
   kDoctorMeaningfulChangeScoreThreshold,
   kDoctorPromptVersion,
@@ -17,6 +20,35 @@ const {
 } = require("./constants");
 
 const kMaxSnippetLines = 20;
+const kDoctorFixDispatchTimeoutMs = 30000;
+
+const buildDoctorFixCompletionInstructions = ({
+  cardId,
+  runId,
+  token,
+  alphaclawRootDir,
+}) => {
+  const completionCommand = [
+    "alphaclaw",
+    "--root-dir",
+    shellEscapeArg(alphaclawRootDir),
+    "doctor finding complete",
+    "--id",
+    shellEscapeArg(String(Number(cardId || 0))),
+    "--run",
+    shellEscapeArg(runId),
+    "--token",
+    shellEscapeArg(token),
+  ].join(" ");
+  return [
+    "AlphaClaw completion callback:",
+    "After you have successfully applied and verified the requested fix, run this command exactly:",
+    "```sh",
+    completionCommand,
+    "```",
+    "Do not call the completion callback if the fix was not applied or verification failed. Explain the problem to the user instead.",
+  ].join("\n");
+};
 
 const shellEscapeArg = (value) => {
   const safeValue = String(value || "");
@@ -91,8 +123,11 @@ const createDoctorService = ({
   getDoctorCardsByRunId,
   getDoctorCard,
   updateDoctorCardStatus,
+  startDoctorCardFix,
+  cancelDoctorCardFix,
   workspaceRoot,
   managedRoot,
+  alphaclawRootDir = process.env.ALPHACLAW_ROOT_DIR || "~/.alphaclaw",
   protectedPaths = [],
   lockedPaths = [],
 }) => {
@@ -133,7 +168,13 @@ const createDoctorService = ({
   };
 
   const cloneRunCards = ({ sourceRunId, targetRunId }) => {
-    const sourceCards = getDoctorCardsByRunId(sourceRunId);
+    const sourceCards = getDoctorCardsByRunId(sourceRunId).map((card) => ({
+      ...card,
+      status:
+        card.status === kDoctorCardStatus.working
+          ? kDoctorCardStatus.open
+          : card.status,
+    }));
     insertDoctorCards({
       runId: targetRunId,
       cards: sourceCards,
@@ -385,7 +426,7 @@ const createDoctorService = ({
 
   const requestCardFix = async ({
     cardId,
-    sessionId = "",
+    sessionKey = "",
     replyChannel = "",
     replyTo = "",
     prompt = "",
@@ -394,28 +435,65 @@ const createDoctorService = ({
     if (!card) throw new Error("Doctor card not found");
     const resolvedPrompt = String(prompt || card.fixPrompt || "").trim();
     if (!resolvedPrompt) throw new Error("Doctor card does not include a fix prompt");
-    let command = `agent --agent main --message ${shellEscapeArg(resolvedPrompt)}`;
-    const trimmedSessionId = String(sessionId || "").trim();
+    const trimmedSessionKey = String(sessionKey || "").trim();
+    if (!trimmedSessionKey) throw new Error("Doctor fix request requires a session key");
     const trimmedReplyChannel = String(replyChannel || "").trim();
     const trimmedReplyTo = String(replyTo || "").trim();
-    if (trimmedReplyChannel && trimmedReplyTo) {
-      command +=
-        ` --deliver --reply-channel ${shellEscapeArg(trimmedReplyChannel)}` +
-        ` --reply-to ${shellEscapeArg(trimmedReplyTo)}`;
-    } else if (trimmedSessionId) {
-      command += ` --session-id ${shellEscapeArg(trimmedSessionId)}`;
+    const runId = `doctor-fix-${Number(card.id || cardId)}-${crypto.randomUUID()}`;
+    const callbackToken = crypto.randomBytes(32).toString("hex");
+    const workingCard = startDoctorCardFix({
+      id: card.id,
+      runId,
+      tokenHash: hashDoctorFixToken(callbackToken),
+    });
+    if (!workingCard) {
+      const currentCard = getDoctorCard(card.id);
+      if (currentCard?.status === kDoctorCardStatus.working) {
+        throw new Error("Doctor fix already in progress");
+      }
+      throw new Error("Doctor finding must be open before requesting a fix");
     }
-    const result = await clawCmd(command, {
-      quiet: true,
-      timeoutMs: kDoctorRunTimeoutMs,
+    const completionInstructions = buildDoctorFixCompletionInstructions({
+      cardId: card.id,
+      runId,
+      token: callbackToken,
+      alphaclawRootDir,
     });
+    const gatewayParams = {
+      idempotencyKey: runId,
+      message: `${resolvedPrompt}\n\n${completionInstructions}`,
+      sessionKey: trimmedSessionKey,
+    };
+    if (trimmedReplyChannel && trimmedReplyTo) {
+      gatewayParams.deliver = true;
+      gatewayParams.replyChannel = trimmedReplyChannel;
+      gatewayParams.replyTo = trimmedReplyTo;
+    }
+    let result = null;
+    try {
+      result = await clawCmd(
+        `gateway call agent --json --timeout ${kDoctorFixDispatchTimeoutMs} --params ${shellEscapeArg(
+          JSON.stringify(gatewayParams),
+        )}`,
+        {
+          quiet: true,
+          timeoutMs: kDoctorFixDispatchTimeoutMs,
+        },
+      );
+    } catch (error) {
+      cancelDoctorCardFix({ id: card.id, runId });
+      throw error;
+    }
     if (!result?.ok) {
+      cancelDoctorCardFix({ id: card.id, runId });
       throw new Error(result?.stderr || "Could not send Doctor fix request");
     }
     return {
       ok: true,
+      queued: true,
+      runId,
       stdout: result.stdout || "",
-      card,
+      card: workingCard,
     };
   };
 
@@ -443,6 +521,7 @@ const createDoctorService = ({
 };
 
 module.exports = {
+  buildDoctorFixCompletionInstructions,
   buildDoctorIdempotencyKey,
   buildDoctorSessionKey,
   buildDoctorSessionId,

package/lib/server/onboarding/index.js

@@ -369,7 +369,14 @@ const createOnboardingService = ({
     vars,
     modelKey,
     importMode = false,
+    onProgress,
   }) => {
+    const reportProgress = (stage) => {
+      if (typeof onProgress !== "function") return;
+      try {
+        onProgress(stage);
+      } catch {}
+    };
     const validation = validateOnboardingInput({
       vars,
       modelKey,
@@ -425,6 +432,7 @@ const createOnboardingService = ({
     syncApiKeyAuthProfilesFromEnvVars(authProfiles, varsToSave);
 
     const [, repoName] = repoUrl.split("/");
+    reportProgress("creating_repo");
     const repoCheck = await ensureGithubRepoAccessible({
       repoUrl,
       repoName,
@@ -481,6 +489,7 @@ const createOnboardingService = ({
       );
     }
 
+    reportProgress("running_openclaw_onboard");
     if (!existingConfigPresent) {
       const onboardArgs = buildOnboardArgs({
         varMap,
@@ -551,6 +560,7 @@ const createOnboardingService = ({
 
     ensureGatewayProxyConfig(getBaseUrl(req));
 
+    reportProgress("initial_git_push");
     try {
       const commitMsg = importMode
         ? "imported existing setup via AlphaClaw"
@@ -567,6 +577,7 @@ const createOnboardingService = ({
       console.error("[onboard] Git push error:", e.message);
     }
 
+    reportProgress("starting_gateway");
     runOnboardedBootSequence();
     return { status: 200, body: { ok: true } };
   };

package/lib/server/onboarding/validation.js

@@ -2,6 +2,14 @@ const { getEnvVarForApiKeyProvider } = require("../auth-profiles");
 
 const kAnthropicSetupTokenPrefix = "sk-ant-oat01-";
 const kAnthropicApiKeyPrefix = "sk-ant-api";
+const kCanonicalCodexOauthModelKeys = new Set([
+  "openai/gpt-5.4-mini",
+  "openai/gpt-5.5",
+]);
+
+const usesCodexOauth = (modelKey, provider) =>
+  provider === "openai-codex" ||
+  kCanonicalCodexOauthModelKeys.has(String(modelKey || "").trim());
 
 const validateAnthropicCredentialShape = (varMap) => {
   const anthropicToken = String(varMap.ANTHROPIC_TOKEN || "").trim();
@@ -71,7 +79,10 @@ const validateOnboardingInput = ({ vars, modelKey, resolveModelProvider, hasCode
   if (!anthropicValidation.ok) return anthropicValidation;
   const githubToken = String(varMap.GITHUB_TOKEN || "");
   const githubRepoInput = String(varMap.GITHUB_WORKSPACE_REPO || "").trim();
-  const selectedProvider = resolveModelProvider(modelKey);
+  const resolvedProvider = resolveModelProvider(modelKey);
+  const selectedProvider = usesCodexOauth(modelKey, resolvedProvider)
+    ? "openai-codex"
+    : resolvedProvider;
   const hasCodexOauth = hasCodexOauthProfile();
   const hasAnyAi = !!(
     varMap.ANTHROPIC_API_KEY ||
@@ -82,7 +93,7 @@ const validateOnboardingInput = ({ vars, modelKey, resolveModelProvider, hasCode
   );
   const hasAi = (() => {
     if (selectedProvider === "openai-codex") {
-      return hasCodexOauth;
+      return hasCodexOauth || !!String(varMap.OPENAI_API_KEY || "").trim();
     }
     if (selectedProvider === "anthropic") {
       return !!(varMap.ANTHROPIC_API_KEY || varMap.ANTHROPIC_TOKEN);
@@ -101,7 +112,7 @@ const validateOnboardingInput = ({ vars, modelKey, resolveModelProvider, hasCode
       return {
         ok: false,
         status: 400,
-        error: "Connect OpenAI Codex OAuth before continuing",
+        error: "Connect OpenAI Codex OAuth or add an OpenAI API key before continuing",
       };
     }
     return {

package/lib/server/routes/doctor.js

@@ -106,13 +106,16 @@ const registerDoctorRoutes = ({ app, requireAuth, doctorService }) => {
     try {
       const result = await doctorService.requestCardFix({
         cardId: req.params.id,
-        sessionId: req.body?.sessionId,
+        sessionKey: req.body?.sessionKey,
         replyChannel: req.body?.replyChannel,
         replyTo: req.body?.replyTo,
         prompt: req.body?.prompt,
       });
-      return res.json(result);
+      return res.status(result?.queued ? 202 : 200).json(result);
     } catch (error) {
+      if (/already in progress|must be open/i.test(error.message || "")) {
+        return res.status(409).json({ ok: false, error: error.message });
+      }
       if (/not found/i.test(error.message || "")) {
         return res.status(404).json({ ok: false, error: error.message });
       }

package/lib/server/routes/onboarding.js

@@ -95,6 +95,28 @@ const registerOnboardingRoutes = ({
   getBaseUrl,
   runOnboardedBootSequence,
 }) => {
+  const kOnboardingProgressMessages = {
+    creating_repo: "Creating repo...",
+    running_openclaw_onboard: "Running openclaw onboard...",
+    initial_git_push: "Initial git commit/push...",
+    starting_gateway: "Starting gateway...",
+  };
+  let onboardingProgress = {
+    active: false,
+    stage: "idle",
+    message: "",
+    updatedAt: null,
+  };
+  const setOnboardingProgress = (stage, { active = true } = {}) => {
+    const normalizedStage = String(stage || "").trim();
+    onboardingProgress = {
+      active,
+      stage: normalizedStage,
+      message: kOnboardingProgressMessages[normalizedStage] || "",
+      updatedAt: new Date().toISOString(),
+    };
+  };
+
   // Keep mutating onboarding routes marker-gated so in-progress imports
   // can promote files before the final completion marker is written.
   const hasExplicitOnboardingMarker = () =>
@@ -157,21 +179,32 @@ const registerOnboardingRoutes = ({
     res.json({ onboarded: hasExplicitOnboardingMarker() });
   });
 
+  app.get("/api/onboard/progress", (req, res) => {
+    res.json(onboardingProgress);
+  });
+
   app.post("/api/onboard", async (req, res) => {
     if (hasExplicitOnboardingMarker())
       return res.json({ ok: false, error: "Already onboarded" });
 
     try {
+      setOnboardingProgress("creating_repo");
       const { vars, modelKey, importMode } = req.body;
       const result = await onboardingService.completeOnboarding({
         req,
         vars,
         modelKey,
         importMode: !!importMode,
+        onProgress: (stage) => setOnboardingProgress(stage),
       });
+      setOnboardingProgress(
+        result.body?.ok ? "starting_gateway" : "failed",
+        { active: false },
+      );
       res.status(result.status).json(result.body);
     } catch (err) {
       console.error("[onboard] Error:", err);
+      setOnboardingProgress("failed", { active: false });
       res.status(500).json({ ok: false, error: sanitizeOnboardingError(err) });
     }
   });

package/lib/server.js

@@ -64,6 +64,8 @@ const {
   getDoctorCardsByRunId,
   getDoctorCard,
   updateDoctorCardStatus,
+  startDoctorCardFix,
+  cancelDoctorCardFix,
 } = require("./server/db/doctor");
 const {
   initAuthDb,
@@ -306,8 +308,11 @@ const doctorService = createDoctorService({
   getDoctorCardsByRunId,
   getDoctorCard,
   updateDoctorCardStatus,
+  startDoctorCardFix,
+  cancelDoctorCardFix,
   workspaceRoot: constants.WORKSPACE_DIR,
   managedRoot: constants.OPENCLAW_DIR,
+  alphaclawRootDir: constants.kRootDir,
   protectedPaths: Array.from(constants.kProtectedBrowsePaths || []),
   lockedPaths: Array.from(constants.kLockedBrowsePaths || []),
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chrysb/alphaclaw",
-  "version": "0.9.27",
+  "version": "0.9.29",
   "publishConfig": {
     "access": "public"
   },