releases/ClaudeDo
2
0
Fork 0
Code Issues 1 Pull Requests 2 Actions Packages Projects Releases 12 Wiki Activity

Merge task branch for: Worker hardening: CLI arg injection, stuck-Running, planning-chain wedge, Fail guard

Browse Source
This commit is contained in:
mika kuns
2026-06-09 10:06:59 +02:00
parent b5cf19b19a 33bdff8a6e
commit 5723b81992
20 changed files with 331 additions and 99 deletions
Download Patch File Download Diff File Expand all files Collapse all files

13
src/ClaudeDo.Worker/Planning/PlanningChainCoordinator.cs
View File

@@ -87,12 +87,8 @@ public sealed class PlanningChainCoordinator
public async Task<string?> OnChildFinishedAsync(
string childTaskId, TaskStatus finalStatus, CancellationToken ct = default)
{
if (finalStatus != TaskStatus.Done) return null;
await using var ctx = await _dbFactory.CreateDbContextAsync(ct);
// The successor is whichever sibling explicitly blocks on this child.
// No status check — UnblockAsync flips legacy Waiting to Queued and is a no-op
// for already-Queued rows in the new layout.
var nextId = await ctx.Tasks
.AsNoTracking()
.Where(t => t.BlockedByTaskId == childTaskId)
@@ -101,7 +97,16 @@ public sealed class PlanningChainCoordinator
.FirstOrDefaultAsync(ct);
if (nextId is null) return null;
if (finalStatus == TaskStatus.Done)
{
await _state().UnblockAsync(nextId, ct);
return nextId;
}
// Child failed or was cancelled: cancel the immediate successor so the chain
// is not left wedged. CancelAsync triggers OnChildTerminalAsync → OnChildFinishedAsync
// for that successor, cascading cancellation through the rest of the chain.
await _state().CancelAsync(nextId, DateTime.UtcNow, ct);
return null;
}
}

11
src/ClaudeDo.Worker/Prime/DailyPrepPrompt.cs
View File

@@ -8,10 +8,13 @@ public static class DailyPrepPrompt
public static string LogPath() =>
System.IO.Path.Combine(ClaudeDo.Data.Paths.AppDataRoot(), "logs", "daily-prep.log");
public static string BuildArgs(int maxTurns) =>
"-p --output-format stream-json --verbose --permission-mode acceptEdits " +
$"--max-turns {maxTurns} " +
$"--allowedTools {CandidatesTool} {SetMyDayTool}";
public static IReadOnlyList<string> BuildArgs(int maxTurns) =>
[
"-p", "--output-format", "stream-json", "--verbose",
"--permission-mode", "acceptEdits",
"--max-turns", maxTurns.ToString(),
"--allowedTools", CandidatesTool, SetMyDayTool,
];
public static string BuildPrompt(int maxTasks, DateOnly today) =>
ClaudeDo.Data.PromptFiles.Render(

21
src/ClaudeDo.Worker/Refine/RefinePrompt.cs
View File

@@ -12,13 +12,22 @@ public static class RefinePrompt
public static string LogPath(string taskId) =>
System.IO.Path.Combine(Paths.AppDataRoot(), "logs", $"refine-{Short(taskId)}.log");
public static string BuildArgs(int maxTurns, bool canReadRepo)
public static IReadOnlyList<string> BuildArgs(int maxTurns, bool canReadRepo)
{
var tools = canReadRepo
? $"{GetTaskTool} {UpdateTaskTool} {AddSubtaskTool} Read Grep Glob"
: $"{GetTaskTool} {UpdateTaskTool} {AddSubtaskTool}";
return "-p --output-format stream-json --verbose --permission-mode acceptEdits " +
$"--max-turns {maxTurns} --allowedTools {tools}";
var args = new List<string>
{
"-p", "--output-format", "stream-json", "--verbose",
"--permission-mode", "acceptEdits",
"--max-turns", maxTurns.ToString(),
"--allowedTools", GetTaskTool, UpdateTaskTool, AddSubtaskTool,
};
if (canReadRepo)
{
args.Add("Read");
args.Add("Grep");
args.Add("Glob");
}
return args;
}
public static string BuildPrompt(TaskEntity task, IEnumerable<SubtaskEntity> subtasks)

7
src/ClaudeDo.Worker/Report/WeekReportService.cs
View File

@@ -69,7 +69,12 @@ public sealed class WeekReportService : IWeekReportService
// alphanumerics, dashes and dots only.
var safeModel = new string(model.Where(c => char.IsLetterOrDigit(c) || c is '-' or '.').ToArray());
if (safeModel.Length == 0) safeModel = "sonnet";
var args = $"-p --output-format stream-json --verbose --permission-mode auto --model {safeModel}";
IReadOnlyList<string> args =
[
"-p", "--output-format", "stream-json", "--verbose",
"--permission-mode", "auto",
"--model", safeModel,
];
var result = await _claude.RunAsync(args, prompt, Path.GetTempPath(), _ => Task.CompletedTask, ct);
if (!result.IsSuccess)
throw new InvalidOperationException(result.ErrorMarkdown ?? "Claude could not generate the report.");

59
src/ClaudeDo.Worker/Runner/ClaudeArgsBuilder.cs
View File

@@ -27,12 +27,12 @@ public sealed class ClaudeArgsBuilder
required = new[] { "summary" },
});
public string Build(ClaudeRunConfig config)
public IReadOnlyList<string> Build(ClaudeRunConfig config)
{
var args = new List<string>
{
"-p",
"--output-format stream-json",
"--output-format", "stream-json",
"--verbose",
};
@@ -40,50 +40,55 @@ public sealed class ClaudeArgsBuilder
|| config.PermissionMode.Equals("bypassPermissions", StringComparison.OrdinalIgnoreCase)
? "auto"
: config.PermissionMode;
args.Add($"--permission-mode {permissionMode}");
args.Add("--permission-mode");
args.Add(permissionMode);
if (config.Model is not null)
args.Add($"--model {config.Model}");
{
args.Add("--model");
args.Add(config.Model);
}
if (config.MaxTurns is int turns && turns > 0)
args.Add($"--max-turns {turns}");
{
args.Add("--max-turns");
args.Add(turns.ToString());
}
if (config.SystemPrompt is not null)
args.Add($"--append-system-prompt {Escape(config.SystemPrompt)}");
{
args.Add("--append-system-prompt");
args.Add(config.SystemPrompt);
}
if (config.AgentPath is not null)
{
var agentJson = JsonSerializer.Serialize(new[] { new { file = config.AgentPath } });
args.Add($"--agents {Escape(agentJson)}");
args.Add("--agents");
args.Add(agentJson);
}
args.Add($"--json-schema {Escape(ResultSchema)}");
args.Add("--json-schema");
args.Add(ResultSchema);
if (config.McpConfigPath is not null)
args.Add($"--mcp-config {Escape(config.McpConfigPath)}");
{
args.Add("--mcp-config");
args.Add(config.McpConfigPath);
}
if (config.AllowedTools is not null)
args.Add($"--allowedTools {config.AllowedTools}");
{
args.Add("--allowedTools");
args.Add(config.AllowedTools);
}
if (config.ResumeSessionId is not null)
args.Add($"--resume {config.ResumeSessionId}");
return string.Join(" ", args);
{
args.Add("--resume");
args.Add(config.ResumeSessionId);
}
private static string Escape(string value)
{
if (value.Contains(' ') || value.Contains('"') || value.Contains('\'')
|| value.Contains('\t') || value.Contains('\n') || value.Contains('\r'))
{
var escaped = value
.Replace("\\", "\\\\")
.Replace("\"", "\\\"")
.Replace("\n", "\\n")
.Replace("\r", "\\r")
.Replace("\t", "\\t");
return $"\"{escaped}\"";
}
return value;
return args;
}
}

5
src/ClaudeDo.Worker/Runner/ClaudeProcess.cs
View File

@@ -18,7 +18,7 @@ public sealed class ClaudeProcess : IClaudeProcess
}
public async Task<RunResult> RunAsync(
string arguments,
IReadOnlyList<string> arguments,
string prompt,
string workingDirectory,
Func<string, Task> onStdoutLine,
@@ -27,7 +27,6 @@ public sealed class ClaudeProcess : IClaudeProcess
var psi = new ProcessStartInfo
{
FileName = _cfg.ClaudeBin,
Arguments = arguments,
WorkingDirectory = workingDirectory,
RedirectStandardInput = true,
RedirectStandardOutput = true,
@@ -37,6 +36,8 @@ public sealed class ClaudeProcess : IClaudeProcess
StandardOutputEncoding = Encoding.UTF8,
StandardErrorEncoding = Encoding.UTF8,
};
foreach (var arg in arguments)
psi.ArgumentList.Add(arg);
using var process = new Process { StartInfo = psi };
process.Start();

2
src/ClaudeDo.Worker/Runner/Interfaces/IClaudeProcess.cs
View File

@@ -3,7 +3,7 @@ namespace ClaudeDo.Worker.Runner;
public interface IClaudeProcess
{
Task<RunResult> RunAsync(
string arguments,
IReadOnlyList<string> arguments,
string prompt,
string workingDirectory,
Func<string, Task> onStdoutLine,

13
src/ClaudeDo.Worker/Runner/TaskRunner.cs
View File

@@ -211,6 +211,8 @@ public sealed class TaskRunner
await _state.StartRunningAsync(taskId, now, ct);
await _broadcaster.TaskStarted(slot, taskId, now);
try
{
var nextRunNumber = lastRun.RunNumber + 1;
var result = await RunOnceAsync(taskId, task.Title, slot, runDir, resolvedConfig, nextRunNumber, false, followUpPrompt, ct);
@@ -225,6 +227,17 @@ public sealed class TaskRunner
await _broadcaster.TaskUpdated(taskId);
}
catch (OperationCanceledException)
{
_logger.LogInformation("Task {TaskId} was cancelled during continue", taskId);
await MarkFailed(taskId, task.Title, slot, "Task cancelled.");
}
catch (Exception ex)
{
_logger.LogError(ex, "Unhandled exception continuing task {TaskId}", taskId);
await MarkFailed(taskId, task.Title, slot, $"Unhandled error: {ex.Message}");
}
}
private readonly record struct RunDirResult(string? RunDir, WorktreeContext? WtCtx, string? FailureReason);

5
src/ClaudeDo.Worker/State/TaskStateService.cs
View File

@@ -196,14 +196,15 @@ public sealed class TaskStateService : ITaskStateService
await using (var ctx = await _dbFactory.CreateDbContextAsync(ct))
{
var affected = await ctx.Tasks
.Where(t => t.Id == taskId && t.Status != TaskStatus.Done)
.Where(t => t.Id == taskId &&
(t.Status == TaskStatus.Running || t.Status == TaskStatus.Queued))
.ExecuteUpdateAsync(s => s
.SetProperty(t => t.Status, TaskStatus.Failed)
.SetProperty(t => t.FinishedAt, finishedAt)
.SetProperty(t => t.Result, error), ct);
if (affected == 0)
return new TransitionResult(false, "Task already done; cannot fail.");
return new TransitionResult(false, "Task not in a failable state (must be Running or Queued).");
}
await OnChildTerminalAsync(taskId, TaskStatus.Failed);

39
tests/ClaudeDo.Worker.Tests/Planning/PlanningChainCoordinatorTests.cs
View File

@@ -125,7 +125,7 @@ public sealed class PlanningChainCoordinatorTests : IDisposable
}
[Fact]
public async Task OnChildFailed_DoesNotAdvanceChain()
public async Task OnChildFailed_CancelsPendingSuccessors_ChainIsNotWedged()
{
await SeedPlanningFamilyAsync("P", 3);
await _sut.SetupChainAsync("P", default);
@@ -139,12 +139,43 @@ public sealed class PlanningChainCoordinatorTests : IDisposable
var advanced = await _sut.OnChildFinishedAsync("P-c0", TaskStatus.Failed, default);
// No "advancement" — the chain does not continue on failure.
Assert.Null(advanced);
var kids = await GetChildrenAsync("P");
Assert.Equal(TaskStatus.Failed, kids[0].Status);
// Successors remain blocked on the failed predecessor.
Assert.Equal(kids[0].Id, kids[1].BlockedByTaskId);
Assert.Equal(kids[1].Id, kids[2].BlockedByTaskId);
// Successors must be Cancelled, not left stuck as Queued.
Assert.Equal(TaskStatus.Cancelled, kids[1].Status);
Assert.Equal(TaskStatus.Cancelled, kids[2].Status);
}
[Fact]
public async Task OnChildFailed_MidChain_CancelsAllDownstreamSuccessors()
{
// Chain: c0 → c1 → c2 → c3. c1 fails mid-chain; c2 and c3 must be cancelled.
await SeedPlanningFamilyAsync("P", 4);
await _sut.SetupChainAsync("P", default);
// Mark c0 Done so c1 was unblocked; c1 ran and failed.
await using (var ctx = _factory.CreateDbContext())
{
var c0 = await ctx.Tasks.FirstAsync(t => t.Id == "P-c0");
c0.Status = TaskStatus.Done;
c0.BlockedByTaskId = null;
var c1 = await ctx.Tasks.FirstAsync(t => t.Id == "P-c1");
c1.Status = TaskStatus.Failed;
c1.BlockedByTaskId = null;
await ctx.SaveChangesAsync();
}
// Announce that c1 finished as Failed — the coordinator must cascade to c2/c3.
var advanced = await _sut.OnChildFinishedAsync("P-c1", TaskStatus.Failed, default);
Assert.Null(advanced);
var kids = await GetChildrenAsync("P");
Assert.Equal(TaskStatus.Done, kids[0].Status);
Assert.Equal(TaskStatus.Failed, kids[1].Status);
Assert.Equal(TaskStatus.Cancelled, kids[2].Status);
Assert.Equal(TaskStatus.Cancelled, kids[3].Status);
}
[Fact]

6
tests/ClaudeDo.Worker.Tests/Prime/DailyPrepPromptTests.cs
View File

@@ -19,8 +19,10 @@ public class DailyPrepPromptTests
public void Build_args_allows_only_the_two_tools()
{
var args = DailyPrepPrompt.BuildArgs(maxTurns: 30);
Assert.Contains("--output-format stream-json", args);
Assert.Contains("--max-turns 30", args);
Assert.Contains("--output-format", args);
Assert.Contains("stream-json", args);
Assert.Contains("--max-turns", args);
Assert.Contains("30", args);
Assert.Contains("--allowedTools", args);
Assert.Contains("mcp__claudedo__get_daily_prep_candidates", args);
Assert.Contains("mcp__claudedo__set_my_day", args);

2
tests/ClaudeDo.Worker.Tests/Prime/PrimeRunnerTests.cs
View File

@@ -31,7 +31,7 @@ public class PrimeRunnerTests : IDisposable
}
public async Task<RunResult> RunAsync(
string arguments,
IReadOnlyList<string> arguments,
string prompt,
string workingDirectory,
Func<string, Task> onStdoutLine,

7
tests/ClaudeDo.Worker.Tests/Refine/RefinePromptTests.cs
View File

@@ -11,9 +11,12 @@ public sealed class RefinePromptTests
{
var args = RefinePrompt.BuildArgs(20, canReadRepo: true);
Assert.Contains("--permission-mode acceptEdits", args);
Assert.Contains("--permission-mode", args);
Assert.Contains("acceptEdits", args);
Assert.Contains("mcp__claudedo__add_subtask", args);
Assert.Contains(" Read Grep Glob", args);
Assert.Contains("Read", args);
Assert.Contains("Grep", args);
Assert.Contains("Glob", args);
}
[Fact]

2
tests/ClaudeDo.Worker.Tests/Refine/RefineRunnerTests.cs
View File

@@ -105,7 +105,7 @@ internal sealed class RecordingClaudeProcess : IClaudeProcess
public RecordingClaudeProcess(bool success) => _success = success;
public Task<RunResult> RunAsync(string arguments, string prompt, string workingDirectory,
public Task<RunResult> RunAsync(IReadOnlyList<string> arguments, string prompt, string workingDirectory,
Func<string, Task> onStdoutLine, CancellationToken ct)
{
Interlocked.Increment(ref _callCount);

2
tests/ClaudeDo.Worker.Tests/Report/WeekReportServiceTests.cs
View File

@@ -27,7 +27,7 @@ public class WeekReportServiceTests : IDisposable
{
public int Calls;
public RunResult Next = new() { ExitCode = 0, ResultMarkdown = "## Bericht" };
public Task<RunResult> RunAsync(string args, string prompt, string wd, Func<string, Task> onLine, CancellationToken ct)
public Task<RunResult> RunAsync(IReadOnlyList<string> args, string prompt, string wd, Func<string, Task> onLine, CancellationToken ct)
{ Calls++; return Task.FromResult(Next); }
}

77
tests/ClaudeDo.Worker.Tests/Runner/ClaudeArgsBuilderTests.cs
View File

@@ -11,9 +11,11 @@ public sealed class ClaudeArgsBuilderTests
{
var args = _builder.Build(new ClaudeRunConfig(null, null, null, null));
Assert.Contains("-p", args);
Assert.Contains("--output-format stream-json", args);
Assert.Contains("--output-format", args);
Assert.Contains("stream-json", args);
Assert.Contains("--verbose", args);
Assert.Contains("--permission-mode auto", args);
Assert.Contains("--permission-mode", args);
Assert.Contains("auto", args);
Assert.DoesNotContain("--dangerously-skip-permissions", args);
Assert.Contains("--json-schema", args);
Assert.DoesNotContain("--model", args);
@@ -26,7 +28,8 @@ public sealed class ClaudeArgsBuilderTests
public void Model_Adds_Model_Flag()
{
var args = _builder.Build(new ClaudeRunConfig("sonnet-4-6", null, null, null));
Assert.Contains("--model sonnet-4-6", args);
Assert.Contains("--model", args);
Assert.Contains("sonnet-4-6", args);
}
[Fact]
@@ -42,63 +45,74 @@ public sealed class ClaudeArgsBuilderTests
{
var args = _builder.Build(new ClaudeRunConfig(null, null, "/path/to/agent.md", null));
Assert.Contains("--agents", args);
Assert.Contains("/path/to/agent.md", args);
Assert.Contains(args, a => a.Contains("/path/to/agent.md"));
}
[Fact]
public void ResumeSessionId_Adds_Resume_Flag()
{
var args = _builder.Build(new ClaudeRunConfig(null, null, null, "sess-abc-123"));
Assert.Contains("--resume sess-abc-123", args);
Assert.Contains("--resume", args);
Assert.Contains("sess-abc-123", args);
}
[Fact]
public void All_Options_Set_Includes_All_Flags()
{
var args = _builder.Build(new ClaudeRunConfig("opus-4-6", "Be thorough.", "/agents/dev.md", "sess-xyz"));
Assert.Contains("--model opus-4-6", args);
Assert.Contains("--model", args);
Assert.Contains("opus-4-6", args);
Assert.Contains("--append-system-prompt", args);
Assert.Contains("--agents", args);
Assert.Contains("--resume sess-xyz", args);
Assert.Contains("--resume", args);
Assert.Contains("sess-xyz", args);
Assert.Contains("--json-schema", args);
}
[Fact]
public void SystemPrompt_With_Quotes_Is_Escaped()
public void SystemPrompt_With_Quotes_Is_Passed_Verbatim()
{
var args = _builder.Build(new ClaudeRunConfig(null, """Don't say "hello".""", null, null));
var prompt = """Don't say "hello".""";
var args = _builder.Build(new ClaudeRunConfig(null, prompt, null, null));
Assert.Contains("--append-system-prompt", args);
Assert.Contains(prompt, args);
}
[Fact]
public void Build_quotes_system_prompt_with_newline()
public void SystemPrompt_With_Newline_Is_Passed_As_Single_Element()
{
var prompt = "line1\nline2";
var args = _builder.Build(new ClaudeRunConfig(
Model: null,
SystemPrompt: "line1\nline2",
SystemPrompt: prompt,
AgentPath: null,
ResumeSessionId: null));
Assert.Contains("--append-system-prompt \"line1\\nline2\"", args);
var list = args.ToList();
var idx = list.IndexOf("--append-system-prompt");
Assert.True(idx >= 0);
Assert.Equal(prompt, list[idx + 1]);
}
[Fact]
public void Build_quotes_system_prompt_with_tab()
public void SystemPrompt_With_Tab_Is_Passed_As_Single_Element()
{
var prompt = "col1\tcol2";
var args = _builder.Build(new ClaudeRunConfig(
Model: null,
SystemPrompt: "col1\tcol2",
SystemPrompt: prompt,
AgentPath: null,
ResumeSessionId: null));
Assert.Contains("\"col1", args);
Assert.Contains(prompt, args);
}
[Fact]
public void MaxTurns_Adds_Flag_When_Positive()
{
var args = _builder.Build(new ClaudeRunConfig(null, null, null, null, MaxTurns: 25));
Assert.Contains("--max-turns 25", args);
Assert.Contains("--max-turns", args);
Assert.Contains("25", args);
}
[Fact]
@@ -114,7 +128,8 @@ public sealed class ClaudeArgsBuilderTests
public void PermissionMode_bypass_Maps_To_Auto()
{
var args = _builder.Build(new ClaudeRunConfig(null, null, null, null, PermissionMode: "bypassPermissions"));
Assert.Contains("--permission-mode auto", args);
Assert.Contains("--permission-mode", args);
Assert.Contains("auto", args);
Assert.DoesNotContain("--dangerously-skip-permissions", args);
}
@@ -122,7 +137,8 @@ public sealed class ClaudeArgsBuilderTests
public void PermissionMode_acceptEdits_Emits_PermissionMode_Flag()
{
var args = _builder.Build(new ClaudeRunConfig(null, null, null, null, PermissionMode: "acceptEdits"));
Assert.Contains("--permission-mode acceptEdits", args);
Assert.Contains("--permission-mode", args);
Assert.Contains("acceptEdits", args);
Assert.DoesNotContain("--dangerously-skip-permissions", args);
}
@@ -130,7 +146,8 @@ public sealed class ClaudeArgsBuilderTests
public void PermissionMode_Null_Defaults_To_Auto()
{
var args = _builder.Build(new ClaudeRunConfig(null, null, null, null));
Assert.Contains("--permission-mode auto", args);
Assert.Contains("--permission-mode", args);
Assert.Contains("auto", args);
Assert.DoesNotContain("--dangerously-skip-permissions", args);
}
@@ -142,8 +159,26 @@ public sealed class ClaudeArgsBuilderTests
McpConfigPath: "C:\\tmp\\t_mcp.json",
AllowedTools: "mcp__claudedo_run__SuggestImprovement"));
Assert.Contains("--mcp-config", args);
Assert.Contains("t_mcp.json", args);
Assert.Contains("--allowedTools mcp__claudedo_run__SuggestImprovement", args);
Assert.Contains(args, a => a.Contains("t_mcp.json"));
Assert.Contains("--allowedTools", args);
Assert.Contains("mcp__claudedo_run__SuggestImprovement", args);
}
[Fact]
public void SystemPrompt_ContainingDangerousFlag_IsPassedAsLiteral_NotAsFlag()
{
// If the system prompt contains "--dangerously-skip-permissions", it must arrive
// as the VALUE of --append-system-prompt, not as a standalone CLI flag.
const string dangerousPrompt = "--dangerously-skip-permissions";
var args = _builder.Build(new ClaudeRunConfig(null, dangerousPrompt, null, null));
var list = args.ToList();
var flagIdx = list.IndexOf("--append-system-prompt");
Assert.True(flagIdx >= 0, "--append-system-prompt flag must be present");
// The dangerous string sits immediately after the flag as its value.
Assert.Equal(dangerousPrompt, list[flagIdx + 1]);
// It does NOT appear as a separate element (i.e., not treated as its own flag).
Assert.Equal(1, list.Count(a => a == dangerousPrompt));
}
}

106
tests/ClaudeDo.Worker.Tests/Runner/ContinueAsyncExceptionTests.cs Normal file
View File

@@ -0,0 +1,106 @@
using ClaudeDo.Data;
using ClaudeDo.Data.Models;
using ClaudeDo.Data.Repositories;
using ClaudeDo.Worker.Config;
using ClaudeDo.Worker.Hub;
using ClaudeDo.Worker.Runner;
using ClaudeDo.Worker.Tests.Infrastructure;
using ClaudeDo.Worker.Tests.Services;
using Microsoft.Extensions.Logging.Abstractions;
using TaskStatus = ClaudeDo.Data.Models.TaskStatus;
namespace ClaudeDo.Worker.Tests.Runner;
/// <summary>
/// Verifies that ContinueAsync wraps RunOnceAsync exceptions so the task
/// is never left stuck in Running status on an unexpected error.
/// </summary>
public sealed class ContinueAsyncExceptionTests : IDisposable
{
private readonly DbFixture _db = new();
private readonly string _tempDir;
private readonly WorkerConfig _cfg;
public ContinueAsyncExceptionTests()
{
_tempDir = Path.Combine(Path.GetTempPath(), $"cd_continue_{Guid.NewGuid():N}");
Directory.CreateDirectory(_tempDir);
_cfg = new WorkerConfig { SandboxRoot = _tempDir, LogRoot = _tempDir };
}
public void Dispose() { _db.Dispose(); try { Directory.Delete(_tempDir, true); } catch { } }
private TaskRunner BuildRunner(IClaudeProcess claude, ClaudeDoDbContext ctx)
{
var dbFactory = _db.CreateFactory();
var broadcaster = new HubBroadcaster(new FakeHubContext());
var state = TaskStateServiceBuilder.Build(dbFactory).State;
var wt = new WorktreeManager(new ClaudeDo.Data.Git.GitService(), dbFactory, _cfg, NullLogger<WorktreeManager>.Instance);
return new TaskRunner(claude, dbFactory, broadcaster, wt, new ClaudeArgsBuilder(), _cfg,
NullLogger<TaskRunner>.Instance, state, new TaskRunTokenRegistry());
}
[Fact]
public async Task ContinueAsync_UnhandledException_MarksTaskFailed_NotStuckRunning()
{
var dbFactory = _db.CreateFactory();
string listId, taskId;
using (var ctx = _db.CreateContext())
{
listId = Guid.NewGuid().ToString();
ctx.Lists.Add(new ListEntity { Id = listId, Name = "L", WorkingDir = null, CreatedAt = DateTime.UtcNow });
taskId = Guid.NewGuid().ToString();
ctx.Tasks.Add(new TaskEntity
{
Id = taskId,
ListId = listId,
Title = "Continue me",
Status = TaskStatus.WaitingForReview,
CreatedAt = DateTime.UtcNow,
});
await ctx.SaveChangesAsync();
// A prior run with a session ID is required for ContinueAsync to proceed.
await new TaskRunRepository(ctx).AddAsync(new TaskRunEntity
{
Id = Guid.NewGuid().ToString(),
TaskId = taskId,
RunNumber = 1,
IsRetry = false,
Prompt = "original prompt",
SessionId = "sess-continue-test",
StartedAt = DateTime.UtcNow.AddMinutes(-5),
FinishedAt = DateTime.UtcNow.AddMinutes(-1),
ExitCode = 0,
ResultMarkdown = "first result",
});
}
// This process throws a non-cancellation exception to simulate an unexpected failure.
var throwingProcess = new ThrowingClaudeProcess(new InvalidOperationException("disk full"));
using var ctx2 = _db.CreateContext();
var runner = BuildRunner(throwingProcess, ctx2);
// ContinueAsync must not propagate the exception and must leave the task in Failed.
await runner.ContinueAsync(taskId, "please continue", "slot-1", CancellationToken.None);
using var verify = _db.CreateContext();
var task = await new TaskRepository(verify).GetByIdAsync(taskId);
Assert.NotNull(task);
Assert.Equal(TaskStatus.Failed, task.Status);
}
private sealed class ThrowingClaudeProcess : IClaudeProcess
{
private readonly Exception _ex;
public ThrowingClaudeProcess(Exception ex) => _ex = ex;
public Task<RunResult> RunAsync(
IReadOnlyList<string> arguments, string prompt, string workingDirectory,
Func<string, Task> onStdoutLine, CancellationToken ct)
=> throw _ex;
}
}

2
tests/ClaudeDo.Worker.Tests/Services/QueueServiceSlotGuardTests.cs
View File

@@ -46,7 +46,7 @@ public sealed class QueueServiceSlotGuardTests : IDisposable
private QueueWaker _waker = null!;
private (QueueService service, FakeClaudeProcess fakeProcess) CreateService(
Func<string, string, string, Func<string, Task>, CancellationToken, Task<RunResult>>? handler = null)
Func<string, string, IReadOnlyList<string>, Func<string, Task>, CancellationToken, Task<RunResult>>? handler = null)
{
var fake = new FakeClaudeProcess(handler);
var broadcaster = new HubBroadcaster(new FakeHubContext());

14
tests/ClaudeDo.Worker.Tests/Services/QueueServiceTests.cs
View File

@@ -47,7 +47,7 @@ public sealed class QueueServiceTests : IDisposable
private QueueWaker _waker = null!;
private (QueueService service, FakeClaudeProcess fakeProcess) CreateService(
Func<string, string, string, Func<string, Task>, CancellationToken, Task<RunResult>>? handler = null)
Func<string, string, IReadOnlyList<string>, Func<string, Task>, CancellationToken, Task<RunResult>>? handler = null)
{
var fake = new FakeClaudeProcess(handler);
var broadcaster = new HubBroadcaster(new FakeHubContext());
@@ -118,7 +118,7 @@ public sealed class QueueServiceTests : IDisposable
{
var (listId, _) = await SeedListWithAgentTag();
string? capturedArgs = null;
IReadOnlyList<string>? capturedArgs = null;
string? capturedPrompt = null;
var done = new TaskCompletionSource();
@@ -157,7 +157,9 @@ public sealed class QueueServiceTests : IDisposable
_waker.Wake();
await done.Task.WaitAsync(TimeSpan.FromSeconds(5));
Assert.Contains("--resume sess-1", capturedArgs);
Assert.NotNull(capturedArgs);
Assert.Contains("--resume", capturedArgs);
Assert.Contains("sess-1", capturedArgs);
Assert.Equal("fix the bug", capturedPrompt);
// Feedback is cleared after the run reaches a successful terminal state (post-run),
@@ -346,19 +348,19 @@ public sealed class QueueServiceTests : IDisposable
internal sealed class FakeClaudeProcess : IClaudeProcess
{
private readonly Func<string, string, string, Func<string, Task>, CancellationToken, Task<RunResult>> _handler;
private readonly Func<string, string, IReadOnlyList<string>, Func<string, Task>, CancellationToken, Task<RunResult>> _handler;
private int _callCount;
public int CallCount => _callCount;
public FakeClaudeProcess(
Func<string, string, string, Func<string, Task>, CancellationToken, Task<RunResult>>? handler = null)
Func<string, string, IReadOnlyList<string>, Func<string, Task>, CancellationToken, Task<RunResult>>? handler = null)
{
_handler = handler ?? ((_, _, _, _, _) =>
Task.FromResult(new RunResult { ExitCode = 0, ResultMarkdown = "ok" }));
}
public async Task<RunResult> RunAsync(string arguments, string prompt, string workingDirectory,
public async Task<RunResult> RunAsync(IReadOnlyList<string> arguments, string prompt, string workingDirectory,
Func<string, Task> onStdoutLine, CancellationToken ct)
{
Interlocked.Increment(ref _callCount);

11
tests/ClaudeDo.Worker.Tests/State/TaskStateServiceTests.cs
View File

@@ -243,6 +243,17 @@ public sealed class TaskStateServiceTests : IDisposable
Assert.Equal(TaskStatus.Done, await GetStatusAsync(id));
}
[Fact]
public async Task FailAsync_FromWaitingForReview_IsNoOp()
{
var id = await SeedTaskAsync(TaskStatus.WaitingForReview);
var result = await _sut.FailAsync(id, DateTime.UtcNow, "oops", default);
Assert.False(result.Ok);
Assert.Equal(TaskStatus.WaitingForReview, await GetStatusAsync(id));
}
// ─── CancelAsync ──────────────────────────────────────────────────────
[Fact]