@joshski/dust 0.1.14 → 0.1.15

package/dist/dust.js

@@ -1121,7 +1121,8 @@ async function* spawnClaudeCode(prompt, options = {}, dependencies = defaultDepe
     model,
     systemPrompt,
     sessionId,
-    dangerouslySkipPermissions
+    dangerouslySkipPermissions,
+    env
   } = options;
   const claudeArguments = [
     "-p",
@@ -1151,7 +1152,8 @@ async function* spawnClaudeCode(prompt, options = {}, dependencies = defaultDepe
   }
   const proc = dependencies.spawn("claude", claudeArguments, {
     cwd,
-    stdio: ["ignore", "pipe", "pipe"]
+    stdio: ["ignore", "pipe", "pipe"],
+    env: { ...process.env, ...env }
   });
   if (!proc.stdout) {
     throw new Error("Failed to get stdout from claude process");
@@ -1563,11 +1565,71 @@ async function next(dependencies) {
 }
 
 // lib/cli/commands/loop.ts
+function formatEvent(event) {
+  switch (event.type) {
+    case "loop.warning":
+      return "⚠️  WARNING: This command skips all permission checks. Only use in a sandbox environment!";
+    case "loop.started":
+      return `\uD83D\uDD04 Starting dust loop claude (max ${event.maxIterations} iterations)...`;
+    case "loop.syncing":
+      return "\uD83D\uDD04 Syncing with remote...";
+    case "loop.sync_skipped":
+      return `Note: git pull skipped (${event.reason})`;
+    case "loop.checking_tasks":
+      return "\uD83D\uDD0D Checking for available tasks...";
+    case "loop.no_tasks":
+      return "\uD83D\uDCA4 No tasks available. Sleeping...";
+    case "loop.tasks_found":
+      return "✨ Found task(s). \uD83E\uDD16 Starting Claude...";
+    case "claude.started":
+      return "\uD83E\uDD16 Claude session started";
+    case "claude.ended":
+      return event.success ? "\uD83E\uDD16 Claude session ended (success)" : `\uD83E\uDD16 Claude session ended (error: ${event.error})`;
+    case "loop.iteration_complete":
+      return `\uD83D\uDCCB Completed iteration ${event.iteration}/${event.maxIterations}`;
+    case "loop.ended":
+      return `\uD83C\uDFC1 Reached max iterations (${event.maxIterations}). Exiting.`;
+  }
+}
+async function defaultPostEvent(url, payload) {
+  await fetch(url, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(payload)
+  });
+}
 function createDefaultDependencies() {
   return {
     spawn: nodeSpawn2,
     run,
-    sleep: (ms) => new Promise((resolve2) => setTimeout(resolve2, ms))
+    sleep: (ms) => new Promise((resolve2) => setTimeout(resolve2, ms)),
+    postEvent: defaultPostEvent
+  };
+}
+function createEventPoster(eventsUrl, sessionId, postEvent, onError) {
+  let sequence = 0;
+  let currentAgentSessionId;
+  return (event) => {
+    if (!eventsUrl)
+      return;
+    sequence++;
+    if (event.type === "claude.started") {
+      currentAgentSessionId = crypto.randomUUID();
+    }
+    const payload = {
+      sequence,
+      timestamp: new Date().toISOString(),
+      sessionId,
+      event
+    };
+    if (event.type.startsWith("claude.") && currentAgentSessionId) {
+      payload.agentSessionId = currentAgentSessionId;
+      payload.agentType = "claude";
+    }
+    postEvent(eventsUrl, payload).catch(onError);
+    if (event.type === "claude.ended") {
+      currentAgentSessionId = undefined;
+    }
   };
 }
 var SLEEP_INTERVAL_MS = 30000;
@@ -1605,16 +1667,17 @@ async function hasAvailableTasks(dependencies) {
   await next({ ...dependencies, context: captureContext });
   return hasOutput;
 }
-async function runOneIteration(dependencies, loopDependencies) {
+async function runOneIteration(dependencies, loopDependencies, emit) {
   const { context } = dependencies;
   const { spawn: spawn2, run: run2 } = loopDependencies;
-  context.stdout("\uD83D\uDD04 Syncing with remote...");
+  emit({ type: "loop.syncing" });
   const pullResult = await gitPull(context.cwd, spawn2);
   if (!pullResult.success) {
-    context.stdout(`⚠️  git pull failed: ${pullResult.message}`);
-    context.stdout("");
-    context.stdout("\uD83E\uDD16 Starting Claude to resolve the conflict...");
-    context.stdout("");
+    emit({
+      type: "loop.sync_skipped",
+      reason: pullResult.message ?? "unknown error"
+    });
+    emit({ type: "claude.started" });
     const prompt = `git pull failed with the following error:
 
 ${pullResult.message}
@@ -1626,42 +1689,39 @@ Please resolve this issue. Common approaches:
 
 Make sure the repository is in a clean state and synced with remote before finishing.`;
     try {
-      await run2(prompt, { cwd: context.cwd, dangerouslySkipPermissions: true });
-      context.stdout("");
-      context.stdout("✅ Claude resolved the git pull conflict. Continuing loop...");
-      context.stdout("");
+      await run2(prompt, {
+        cwd: context.cwd,
+        dangerouslySkipPermissions: true,
+        env: { DUST_UNATTENDED: "1" }
+      });
+      emit({ type: "claude.ended", success: true });
       return "resolved_pull_conflict";
     } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      context.stderr(`Claude failed to resolve git pull conflict: ${message}`);
-      context.stdout("");
-      context.stdout("⚠️  Continuing loop despite unresolved conflict...");
-      context.stdout("");
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      context.stderr(`Claude failed to resolve git pull conflict: ${errorMessage}`);
+      emit({ type: "claude.ended", success: false, error: errorMessage });
     }
   }
-  context.stdout("\uD83D\uDD0D Checking for available tasks...");
+  emit({ type: "loop.checking_tasks" });
   const hasTasks = await hasAvailableTasks(dependencies);
   if (!hasTasks) {
-    context.stdout("\uD83D\uDCA4 No tasks available. Sleeping...");
-    context.stdout("");
+    emit({ type: "loop.no_tasks" });
     return "no_tasks";
   }
-  context.stdout("✨ Found a task!");
-  context.stdout("");
-  context.stdout("\uD83E\uDD16 Starting Claude...");
-  context.stdout("");
+  emit({ type: "loop.tasks_found" });
+  emit({ type: "claude.started" });
   try {
-    await run2("go", { cwd: context.cwd, dangerouslySkipPermissions: true });
-    context.stdout("");
-    context.stdout("✅ Claude session complete. Continuing loop...");
-    context.stdout("");
+    await run2("go", {
+      cwd: context.cwd,
+      dangerouslySkipPermissions: true,
+      env: { DUST_UNATTENDED: "1" }
+    });
+    emit({ type: "claude.ended", success: true });
     return "ran_claude";
   } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    context.stderr(`Claude exited with error: ${message}`);
-    context.stdout("");
-    context.stdout("✅ Claude session complete. Continuing loop...");
-    context.stdout("");
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    context.stderr(`Claude exited with error: ${errorMessage}`);
+    emit({ type: "claude.ended", success: false, error: errorMessage });
     return "claude_error";
   }
 }
@@ -1676,25 +1736,38 @@ function parseMaxIterations(commandArguments) {
   return parsed;
 }
 async function loopClaude(dependencies, loopDependencies = createDefaultDependencies()) {
-  const { context } = dependencies;
+  const { context, settings } = dependencies;
+  const { postEvent } = loopDependencies;
   const maxIterations = parseMaxIterations(dependencies.arguments);
-  context.stdout("⚠️  WARNING: This command skips all permission checks. Only use in a sandbox environment!");
-  context.stdout("");
-  context.stdout(`\uD83D\uDD04 Starting dust loop claude (max ${maxIterations} iterations)...`);
+  const eventsUrl = settings.eventsUrl;
+  const sessionId = crypto.randomUUID();
+  const postTypedEvent = createEventPoster(eventsUrl, sessionId, postEvent, (error) => {
+    const message = error instanceof Error ? error.message : String(error);
+    context.stderr(`Event POST failed: ${message}`);
+  });
+  const emit = (event) => {
+    context.stdout(formatEvent(event));
+    postTypedEvent(event);
+  };
+  emit({ type: "loop.warning" });
+  emit({ type: "loop.started", maxIterations });
   context.stdout("   Press Ctrl+C to stop");
   context.stdout("");
   let completedIterations = 0;
   while (completedIterations < maxIterations) {
-    const result = await runOneIteration(dependencies, loopDependencies);
+    const result = await runOneIteration(dependencies, loopDependencies, emit);
     if (result === "no_tasks") {
       await loopDependencies.sleep(SLEEP_INTERVAL_MS);
     } else {
       completedIterations++;
-      context.stdout(`\uD83D\uDCCB Completed iteration ${completedIterations}/${maxIterations}`);
-      context.stdout("");
+      emit({
+        type: "loop.iteration_complete",
+        iteration: completedIterations,
+        maxIterations
+      });
     }
   }
-  context.stdout(`\uD83C\uDFC1 Reached max iterations (${maxIterations}). Exiting.`);
+  emit({ type: "loop.ended", maxIterations });
   return { exitCode: 0 };
 }
 
@@ -1795,8 +1868,45 @@ async function getChangesFromRemote(cwd, gitRunner) {
   }
   return parseGitDiffNameStatus(diffResult.output);
 }
+async function getUncommittedFiles(cwd, gitRunner) {
+  const result = await gitRunner.run(["status", "--porcelain"], cwd);
+  if (result.exitCode !== 0 || !result.output.trim()) {
+    return [];
+  }
+  const files = [];
+  const lines = result.output.split(`
+`).filter((line) => line.length > 0);
+  for (const line of lines) {
+    if (line.length > 3) {
+      const path = line.substring(3);
+      const arrowIndex = path.indexOf(" -> ");
+      if (arrowIndex !== -1) {
+        files.push(path.substring(arrowIndex + 4));
+      } else {
+        files.push(path);
+      }
+    }
+  }
+  return files;
+}
 async function prePush(dependencies, gitRunner = defaultGitRunner, env = process.env) {
   const { context } = dependencies;
+  if (env.DUST_UNATTENDED) {
+    const uncommittedFiles = await getUncommittedFiles(context.cwd, gitRunner);
+    if (uncommittedFiles.length > 0) {
+      context.stderr("");
+      context.stderr("⚠️  Push blocked: uncommitted changes detected in unattended mode.");
+      context.stderr("");
+      context.stderr("You are running in unattended mode (DUST_UNATTENDED=1) and have uncommitted files:");
+      for (const file of uncommittedFiles) {
+        context.stderr(`  → ${file}`);
+      }
+      context.stderr("");
+      context.stderr("Commit or discard these changes before pushing to avoid broken builds.");
+      context.stderr("");
+      return { exitCode: 1 };
+    }
+  }
   const changes = await getChangesFromRemote(context.cwd, gitRunner);
   if (changes.length > 0) {
     const analysis = analyzeChangesForTaskOnlyPattern(changes);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@joshski/dust",
-  "version": "0.1.14",
+  "version": "0.1.15",
   "description": "Flow state for AI coding agents",
   "type": "module",
   "bin": {