@rallycry/conveyor-agent 9.0.2 → 9.1.0

package/dist/{chunk-5W6MHROF.js → chunk-P3QCTUHC.js}

@@ -541,24 +541,23 @@ var AgentConnection = class _AgentConnection {
     };
   }
   // ── Convenience methods (thin wrappers around call / emit) ─────────
-  async emitStatus(status) {
+  async emitStatus(status, reason) {
     this.lastEmittedStatus = status;
     await this.flushEvents();
+    const payload = {
+      sessionId: this.config.sessionId,
+      status,
+      ...reason ? { reason } : {}
+    };
     const AWAIT_STATUSES = ["idle", "waiting_for_input", "connected"];
     if (AWAIT_STATUSES.includes(status)) {
       try {
-        await this.call("reportAgentStatus", {
-          sessionId: this.config.sessionId,
-          status
-        });
+        await this.call("reportAgentStatus", payload);
         this.lastReportedStatus = status;
       } catch {
       }
     } else {
-      void this.call("reportAgentStatus", {
-        sessionId: this.config.sessionId,
-        status
-      }).then(() => {
+      void this.call("reportAgentStatus", payload).then(() => {
         this.lastReportedStatus = status;
       }).catch(() => {
       });
@@ -1058,7 +1057,18 @@ function restoreWipSnapshot(cwd, branch) {
       stdio: ["ignore", "pipe", "ignore"]
     }).toString().trim();
     const head = execSync("git rev-parse HEAD", { cwd, stdio: ["ignore", "pipe", "ignore"] }).toString().trim();
-    if (parent !== head) return "stale";
+    if (parent !== head) {
+      try {
+        execSync(`git stash apply ${sha}`, { cwd, stdio: ["ignore", "pipe", "pipe"] });
+        return "applied";
+      } catch {
+        try {
+          execSync("git reset --merge", { cwd, stdio: "ignore" });
+        } catch {
+        }
+        return "stale";
+      }
+    }
     execSync(`git stash apply ${sha}`, { cwd, stdio: ["ignore", "pipe", "pipe"] });
     return "applied";
   } catch {
@@ -1276,6 +1286,7 @@ const net = require("node:net");
 const crypto = require("node:crypto");
 
 const PRE_TOOL_USE_TIMEOUT_MS = 110000;
+const ASK_USER_QUESTION_TIMEOUT_MS = 5000;
 
 let raw = "";
 process.stdin.setEncoding("utf8");
@@ -1347,17 +1358,26 @@ function preToolUse(payload) {
     );
     process.exit(0);
   };
-  const denyUnavailable = () =>
-    respond(
-      "deny",
-      "Conveyor validation is unavailable right now. Wait a moment and call the tool again.",
-    );
+  // AskUserQuestion is observe-only (status reporting) \u2014 fail OPEN so a
+  // missing/slow socket never denies the questionnaire. Everything else
+  // (ExitPlanMode) is a Conveyor gate \u2014 fail CLOSED.
+  const failOpen = payload.tool_name === "AskUserQuestion";
+  const respondUnavailable = () =>
+    failOpen
+      ? respond("allow")
+      : respond(
+          "deny",
+          "Conveyor validation is unavailable right now. Wait a moment and call the tool again.",
+        );
   if (!socketPath) {
-    denyUnavailable();
+    respondUnavailable();
     return;
   }
   const id = crypto.randomBytes(8).toString("hex");
-  const timer = setTimeout(denyUnavailable, PRE_TOOL_USE_TIMEOUT_MS);
+  const timer = setTimeout(
+    respondUnavailable,
+    failOpen ? ASK_USER_QUESTION_TIMEOUT_MS : PRE_TOOL_USE_TIMEOUT_MS,
+  );
   const client = net.connect(socketPath, () => {
     client.write(
       JSON.stringify({
@@ -1392,11 +1412,11 @@ function preToolUse(payload) {
   });
   client.on("error", () => {
     clearTimeout(timer);
-    denyUnavailable();
+    respondUnavailable();
   });
   client.on("close", () => {
     clearTimeout(timer);
-    denyUnavailable();
+    respondUnavailable();
   });
 }
 `;
@@ -1434,6 +1454,13 @@ async function writeHookSettings(dir) {
         {
           matcher: "ExitPlanMode",
           hooks: [{ type: "command", command: `node ${JSON.stringify(helperPath)}`, timeout: 120 }]
+        },
+        {
+          // Observe-only: lets the session report waiting_for_input the moment
+          // the planning questionnaire renders. The helper fails open for this
+          // tool, so the questionnaire is never blocked by Conveyor.
+          matcher: "AskUserQuestion",
+          hooks: [{ type: "command", command: `node ${JSON.stringify(helperPath)}`, timeout: 30 }]
         }
       ],
       PostToolUse: [
@@ -1671,7 +1698,9 @@ var ConnectAgentRequestSchema = z.object({
 });
 var ReportAgentStatusRequestSchema = z.object({
   sessionId: z.string(),
-  status: z.string()
+  status: z.string(),
+  /** Why the agent reports this status (e.g. "user_question" while an AskUserQuestion questionnaire is pending in the TUI). */
+  reason: z.string().optional()
 });
 var NotifyAgentVersionRequestSchema = z.object({
   sessionId: z.string(),
@@ -1986,6 +2015,20 @@ var GetProjectTaskSessionsRequestSchema = z2.object({
   projectId: z2.string(),
   taskId: z2.string()
 });
+var QueryProjectGcpLogsRequestSchema = z2.object({
+  projectId: z2.string(),
+  env: z2.enum(["prod", "dev", "claudespace"]).optional(),
+  severity: z2.enum(["DEBUG", "INFO", "NOTICE", "WARNING", "ERROR", "CRITICAL", "ALERT", "EMERGENCY"]).optional(),
+  services: z2.array(z2.string().min(1).max(200)).max(25).optional(),
+  sqlInstances: z2.array(z2.string().min(1).max(200)).max(25).optional(),
+  allServices: z2.boolean().optional(),
+  search: z2.string().max(256).optional(),
+  filter: z2.string().max(1e3).optional(),
+  startTime: z2.string().optional(),
+  endTime: z2.string().optional(),
+  limit: z2.number().int().min(1).max(200).optional().default(50),
+  pageToken: z2.string().max(4096).optional()
+});
 var StartProjectBuildRequestSchema = z2.object({
   projectId: z2.string(),
   taskId: z2.string(),
@@ -2164,6 +2207,7 @@ var CreateProjectSuggestionRequestSchema = z2.object({
   tagNames: z2.array(z2.string()).optional(),
   requestingUserId: z2.string().optional()
 });
+var AGENT_STATUS_REASON_USER_QUESTION = "user_question";
 var TASK_CHAT_HISTORY_LIMIT = 20;
 var PM_CHAT_HISTORY_LIMIT = 40;
 var AGENT_CHAT_HISTORY_FETCH_LIMIT = Math.max(TASK_CHAT_HISTORY_LIMIT, PM_CHAT_HISTORY_LIMIT) + 10;
@@ -3096,6 +3140,25 @@ async function transcriptSize(path) {
     return 0;
   }
 }
+function parseUserQuestions(input) {
+  if (!Array.isArray(input.questions)) return [];
+  const questions = [];
+  for (const entry of input.questions) {
+    if (!isRecord2(entry)) continue;
+    if (typeof entry.question !== "string") continue;
+    const options = Array.isArray(entry.options) ? entry.options.filter(isRecord2).filter((o) => typeof o.label === "string").map((o) => ({
+      label: o.label,
+      description: typeof o.description === "string" ? o.description : ""
+    })) : [];
+    questions.push({
+      question: entry.question,
+      header: typeof entry.header === "string" ? entry.header : "",
+      options,
+      ...typeof entry.multiSelect === "boolean" ? { multiSelect: entry.multiSelect } : {}
+    });
+  }
+  return questions;
+}
 var PtySession = class {
   constructor(prompt, options, resume, bridge) {
     this.prompt = prompt;
@@ -3373,11 +3436,17 @@ var PtySession = class {
   }
   /**
    * PreToolUse request from the hook helper → the runner's `canUseTool`
-   * verdict. Only ExitPlanMode is matched by the settings hook, so this is
-   * the Conveyor plan-exit gate (validation + identification trigger run
-   * inside the callback). Absent callback → allow (mirrors the SDK default).
+   * verdict. ExitPlanMode is the Conveyor plan-exit gate (validation +
+   * identification trigger run inside the callback); AskUserQuestion is
+   * observed and always allowed. Absent callback → allow (mirrors the SDK
+   * default).
    */
   async handlePreToolUse(request) {
+    if (request.tool_name === "AskUserQuestion") {
+      this.disarmSubmitNudge();
+      this.queue.push({ type: "user_question", questions: parseUserQuestions(request.tool_input) });
+      return { decision: "allow" };
+    }
     const canUseTool = this.options.canUseTool;
     let verdict;
     if (canUseTool) {
@@ -6445,6 +6514,44 @@ async function handleResultCase(event, host, context, startTime, isTyping, lastA
 }
 
 // src/execution/event-processor.ts
+function hasAskUserQuestionBlock(event) {
+  return event.message.content.some((b) => b.type === "tool_use" && b.name === "AskUserQuestion");
+}
+async function armQuestionPending(host, state) {
+  state.questionPending = true;
+  await host.connection.emitStatus("waiting_for_input", AGENT_STATUS_REASON_USER_QUESTION);
+  await host.callbacks.onStatusChange("waiting_for_input");
+}
+async function clearQuestionPending(host, state, options) {
+  if (!state.questionPending) return;
+  state.questionPending = false;
+  if (options.emitRunning) {
+    await host.connection.emitStatus("running");
+    await host.callbacks.onStatusChange("running");
+  }
+}
+async function applyQuestionTransitions(event, host, state) {
+  switch (event.type) {
+    case "user_question":
+      await armQuestionPending(host, state);
+      return;
+    case "assistant":
+      if (!hasAskUserQuestionBlock(event)) {
+        await clearQuestionPending(host, state, { emitRunning: true });
+      }
+      return;
+    case "tool_progress":
+      if (event.tool_name === "AskUserQuestion") {
+        await clearQuestionPending(host, state, { emitRunning: true });
+      }
+      return;
+    case "result":
+      await clearQuestionPending(host, state, { emitRunning: false });
+      return;
+    default:
+      break;
+  }
+}
 function stopTypingIfNeeded(host, isTyping) {
   if (isTyping) host.connection.sendTypingStop();
 }
@@ -6524,13 +6631,14 @@ async function processEvents(events, context, host) {
     staleSession: void 0,
     authError: void 0,
     lastAssistantUsage: void 0,
-    turnToolCalls: []
+    turnToolCalls: [],
+    questionPending: false
   };
   for await (const event of events) {
     if (host.isStopped()) break;
     flushPendingToolCalls(host, state.turnToolCalls);
     const now = Date.now();
-    if (now - lastStatusEmit >= STATUS_REEMIT_INTERVAL_MS) {
+    if (now - lastStatusEmit >= STATUS_REEMIT_INTERVAL_MS && !state.questionPending) {
       host.connection.emitStatus("running");
       lastStatusEmit = now;
     }
@@ -6538,6 +6646,7 @@ async function processEvents(events, context, host) {
       stopTypingIfNeeded(host, state.isTyping);
       return { retriable: false, modeRestart: true };
     }
+    await applyQuestionTransitions(event, host, state);
     switch (event.type) {
       case "system":
         await processSystemCase(event, host, context, state);
@@ -8882,4 +8991,4 @@ export {
   runStartCommand,
   unshallowRepo
 };
-//# sourceMappingURL=chunk-5W6MHROF.js.map
+//# sourceMappingURL=chunk-P3QCTUHC.js.map