288 lines
15 KiB
C#
288 lines
15 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Diagnostics;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using System.Text;
|
|
using System.Text.Json;
|
|
using System.Threading.Tasks;
|
|
|
|
namespace QuickClaude
|
|
{
|
|
// Runs one turn of Claude Code in headless mode and reports what happens.
|
|
public class ClaudeRunner
|
|
{
|
|
public event Action<string> TextDelta; // reply text as it streams
|
|
public event Action<string> ToolUsed; // one line describing a tool call
|
|
public event Action<string> SessionStarted; // session id
|
|
public event Action<string> Finished; // null when fine, otherwise an error message
|
|
|
|
Process proc;
|
|
public bool Running => proc != null && !proc.HasExited;
|
|
|
|
const string StylePrompt =
|
|
"Your replies appear in a tiny plain-text note on the user's Windows desktop. " +
|
|
"Keep answers short and conversational. Write plain text only: no markdown headings, " +
|
|
"no bold or italics, no tables, no code fences unless he asks for code. " +
|
|
"Never use em dashes or en dashes.";
|
|
|
|
const string ToolsPrompt =
|
|
"You are running inside QuickClaude, a small note window on the user's Windows PC. " +
|
|
"You have web search, web fetch, and access to files in the user's home folder " +
|
|
"(Downloads, Documents, Desktop and so on). Use them when they help instead of saying you can't. " +
|
|
"Whether you can change files depends on the user's \"Claude can\" setting in QuickClaude's tray menu; " +
|
|
"if Write or Edit is unavailable, say they can switch it to \"Edit files in the work folder\". " +
|
|
"For anything on the web, use the WebSearch and WebFetch tools (load them with ToolSearch first if they " +
|
|
"aren't loaded yet). They work here without asking the user, even if earlier in this conversation they were blocked. " +
|
|
"Never use PowerShell, Bash, curl or Invoke-WebRequest to search the web or fetch web pages. " +
|
|
"Never put the user's email address, email or website domain, name, account or organization details, " +
|
|
"or other personal information from your context into web searches or URLs you fetch, " +
|
|
"unless the user specifically asks you to search for them. " +
|
|
"Shell commands (Bash or PowerShell) are allowed for other things, but each one first shows the user a confirm box; " +
|
|
"if they decline, carry on without it. " +
|
|
"When the user asks you to open something, run exactly one PowerShell Start-Process command with one quoted target " +
|
|
"and nothing else on the line (no arguments, no second command); those open without a confirm box. " +
|
|
"A website: Start-Process \"https://x.com\" (always the full https:// URL). " +
|
|
"A folder: Start-Process \"C:\\wallpapers\" (the full path). " +
|
|
"A program: Start-Process mspaint (just its name). If QuickClaude answers that the name isn't on the PATH and gives " +
|
|
"a Start Menu shortcut, run Start-Process with that shortcut's full path, exactly as given.";
|
|
|
|
// Run without prompts. Bash and PowerShell stay out so they go through the confirm box hook.
|
|
// Write and Edit only when the user picked "Edit files" or "Auto"; "Only look" removes them outright.
|
|
const string ReadTools = "WebSearch,WebFetch,Read,Glob,Grep";
|
|
const string EditTools = "Write,Edit,NotebookEdit";
|
|
|
|
public static string FindClaude(string preferred)
|
|
{
|
|
if (!string.IsNullOrWhiteSpace(preferred) && File.Exists(preferred)) return preferred;
|
|
|
|
var candidates = new List<string>();
|
|
var path = Environment.GetEnvironmentVariable("PATH") ?? "";
|
|
foreach (var dir in path.Split(';', StringSplitOptions.RemoveEmptyEntries))
|
|
{
|
|
candidates.Add(Path.Combine(dir.Trim(), "claude.exe"));
|
|
candidates.Add(Path.Combine(dir.Trim(), "claude.cmd"));
|
|
}
|
|
var home = Environment.GetFolderPath(Environment.SpecialFolder.UserProfile);
|
|
var appData = Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData);
|
|
var local = Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData);
|
|
candidates.Add(Path.Combine(home, ".local", "bin", "claude.exe"));
|
|
candidates.Add(Path.Combine(appData, "npm", "claude.cmd"));
|
|
candidates.Add(Path.Combine(home, "scoop", "shims", "claude.exe"));
|
|
|
|
foreach (var c in candidates)
|
|
if (File.Exists(c)) return c;
|
|
|
|
// Copies of Claude Code that the Claude desktop app keeps for itself
|
|
foreach (var root in new[] { Path.Combine(appData, "Claude", "claude-code"), Path.Combine(local, "Claude", "claude-code") })
|
|
{
|
|
try
|
|
{
|
|
if (!Directory.Exists(root)) continue;
|
|
var found = Directory.GetFiles(root, "claude.exe", SearchOption.AllDirectories)
|
|
.OrderByDescending(f => File.GetLastWriteTimeUtc(f)).FirstOrDefault();
|
|
if (found != null) return found;
|
|
}
|
|
catch { }
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public async Task RunAsync(string claudePath, string prompt, string workDir, string sessionId, string mode)
|
|
{
|
|
var psi = new ProcessStartInfo
|
|
{
|
|
RedirectStandardInput = true,
|
|
RedirectStandardOutput = true,
|
|
RedirectStandardError = true,
|
|
UseShellExecute = false,
|
|
CreateNoWindow = true,
|
|
WorkingDirectory = Directory.Exists(workDir) ? workDir : Environment.GetFolderPath(Environment.SpecialFolder.UserProfile),
|
|
StandardInputEncoding = new UTF8Encoding(false),
|
|
StandardOutputEncoding = new UTF8Encoding(false),
|
|
StandardErrorEncoding = new UTF8Encoding(false),
|
|
};
|
|
|
|
var args = new List<string> {
|
|
"-p", "--output-format", "stream-json", "--verbose", "--include-partial-messages",
|
|
"--append-system-prompt", StylePrompt + "\n\n" + ToolsPrompt,
|
|
};
|
|
bool canEdit = mode == "acceptEdits" || mode == "auto";
|
|
args.Add("--allowedTools"); args.Add(canEdit ? ReadTools + "," + EditTools : ReadTools);
|
|
if (!canEdit) { args.Add("--disallowedTools"); args.Add(EditTools); }
|
|
var home = Environment.GetEnvironmentVariable("USERPROFILE");
|
|
if (!string.IsNullOrEmpty(home) && Directory.Exists(home)) { args.Add("--add-dir"); args.Add(home); }
|
|
// Claude Code otherwise keeps a resumed conversation's first system prompt, so prompt
|
|
// changes here would never reach older conversations. Needs Claude Code v2.1.257+.
|
|
args.Add("--system-prompt-snapshot"); args.Add("off");
|
|
if (!string.IsNullOrEmpty(sessionId)) { args.Add("--resume"); args.Add(sessionId); }
|
|
if (!string.IsNullOrEmpty(mode) && mode != "default") { args.Add("--permission-mode"); args.Add(mode); }
|
|
args.Add("--settings"); args.Add(ConfirmHookSettings());
|
|
|
|
if (claudePath.EndsWith(".cmd", StringComparison.OrdinalIgnoreCase))
|
|
{
|
|
psi.FileName = Environment.GetEnvironmentVariable("ComSpec") ?? "cmd.exe";
|
|
psi.ArgumentList.Add("/c");
|
|
psi.ArgumentList.Add(claudePath);
|
|
}
|
|
else psi.FileName = claudePath;
|
|
foreach (var a in args) psi.ArgumentList.Add(a);
|
|
|
|
var stderr = new StringBuilder();
|
|
bool gotText = false, gotResult = false;
|
|
string error = null;
|
|
|
|
try
|
|
{
|
|
proc = Process.Start(psi);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Finished?.Invoke("Couldn't start Claude Code: " + ex.Message);
|
|
return;
|
|
}
|
|
|
|
var errTask = Task.Run(async () =>
|
|
{
|
|
string l;
|
|
while ((l = await proc.StandardError.ReadLineAsync()) != null) stderr.AppendLine(l);
|
|
});
|
|
|
|
try
|
|
{
|
|
await proc.StandardInput.WriteAsync(prompt);
|
|
proc.StandardInput.Close();
|
|
}
|
|
catch { }
|
|
|
|
string line;
|
|
while ((line = await proc.StandardOutput.ReadLineAsync()) != null)
|
|
{
|
|
if (string.IsNullOrWhiteSpace(line)) continue;
|
|
try
|
|
{
|
|
using var doc = JsonDocument.Parse(line);
|
|
var root = doc.RootElement;
|
|
var type = Str(root, "type");
|
|
bool main = !root.TryGetProperty("parent_tool_use_id", out var parent) || parent.ValueKind == JsonValueKind.Null;
|
|
|
|
if (type == "system" && Str(root, "subtype") == "init")
|
|
{
|
|
var sid = Str(root, "session_id");
|
|
if (!string.IsNullOrEmpty(sid)) SessionStarted?.Invoke(sid);
|
|
}
|
|
else if (type == "stream_event" && main && root.TryGetProperty("event", out var ev))
|
|
{
|
|
var evType = Str(ev, "type");
|
|
if (evType == "content_block_delta" && ev.TryGetProperty("delta", out var d) && Str(d, "type") == "text_delta")
|
|
{
|
|
var t = Str(d, "text");
|
|
if (!string.IsNullOrEmpty(t)) { gotText = true; TextDelta?.Invoke(t); }
|
|
}
|
|
else if (evType == "content_block_start" && ev.TryGetProperty("content_block", out var cb) && Str(cb, "type") == "text")
|
|
{
|
|
TextDelta?.Invoke("\u0001"); // marker: a new text block starts
|
|
}
|
|
}
|
|
else if (type == "assistant" && main && root.TryGetProperty("message", out var msg)
|
|
&& msg.TryGetProperty("content", out var content) && content.ValueKind == JsonValueKind.Array)
|
|
{
|
|
foreach (var block in content.EnumerateArray())
|
|
if (Str(block, "type") == "tool_use")
|
|
ToolUsed?.Invoke(DescribeTool(block));
|
|
}
|
|
else if (type == "result")
|
|
{
|
|
gotResult = true;
|
|
var sid = Str(root, "session_id");
|
|
if (!string.IsNullOrEmpty(sid)) SessionStarted?.Invoke(sid);
|
|
bool isError = root.TryGetProperty("is_error", out var ie) && ie.ValueKind == JsonValueKind.True;
|
|
var result = Str(root, "result");
|
|
if (isError) error = string.IsNullOrEmpty(result) ? "Claude Code reported an error." : result;
|
|
else if (!gotText && !string.IsNullOrEmpty(result)) TextDelta?.Invoke(result);
|
|
}
|
|
}
|
|
catch { /* ignore lines that aren't JSON */ }
|
|
}
|
|
|
|
await errTask;
|
|
proc.WaitForExit();
|
|
int code = proc.ExitCode;
|
|
proc.Dispose();
|
|
proc = null;
|
|
|
|
if (error == null && !gotResult)
|
|
{
|
|
var e = stderr.ToString().Trim();
|
|
if (code == -1 || code == 137 || code == 143) error = "Stopped.";
|
|
else error = string.IsNullOrEmpty(e) ? $"Claude Code exited without an answer (code {code})." : e;
|
|
}
|
|
Finished?.Invoke(error);
|
|
}
|
|
|
|
// File writes also go through a guard hook ("QuickClaude.exe --guard-write") that blocks the
|
|
// Desktop and AppData, where OpenRules lets things open without asking.
|
|
// Shell commands go through QuickClaude's own confirm box: a PreToolUse hook that runs
|
|
// "QuickClaude.exe --confirm" (exec form, so no shell quoting). The dialog denies after
|
|
// 2 minutes; the hook timeout is a bit longer so Claude Code never cuts it off first.
|
|
// Written to a file rather than passed inline, since cmd /c (for claude.cmd) mangles JSON quotes.
|
|
static string ConfirmHookSettings()
|
|
{
|
|
var exe = Environment.ProcessPath ?? Process.GetCurrentProcess().MainModule.FileName;
|
|
var json = JsonSerializer.Serialize(new
|
|
{
|
|
hooks = new
|
|
{
|
|
PreToolUse = new[]
|
|
{
|
|
new
|
|
{
|
|
matcher = "Bash|PowerShell|Monitor", // Monitor also runs shell commands
|
|
hooks = new[] { new { type = "command", command = exe, args = new[] { "--confirm" }, timeout = 150 } }
|
|
},
|
|
new
|
|
{
|
|
// Never lets Claude write to the Desktop or AppData (see WriteGuard)
|
|
matcher = "Write|Edit|MultiEdit|NotebookEdit",
|
|
hooks = new[] { new { type = "command", command = exe, args = new[] { "--guard-write" }, timeout = 30 } }
|
|
}
|
|
}
|
|
}
|
|
});
|
|
var path = Path.Combine(Settings.Folder, "hook-settings.json");
|
|
Directory.CreateDirectory(Settings.Folder);
|
|
File.WriteAllText(path, json, new UTF8Encoding(false));
|
|
return path;
|
|
}
|
|
|
|
public void Stop()
|
|
{
|
|
try { if (Running) proc.Kill(true); } catch { }
|
|
}
|
|
|
|
static string Str(JsonElement e, string name) =>
|
|
e.ValueKind == JsonValueKind.Object && e.TryGetProperty(name, out var v) && v.ValueKind == JsonValueKind.String ? v.GetString() : null;
|
|
|
|
static string DescribeTool(JsonElement block)
|
|
{
|
|
var name = Str(block, "name") ?? "tool";
|
|
string detail = null;
|
|
if (block.TryGetProperty("input", out var input))
|
|
{
|
|
foreach (var key in new[] { "description", "file_path", "path", "pattern", "url", "query", "command", "prompt" })
|
|
{
|
|
detail = Str(input, key);
|
|
if (!string.IsNullOrEmpty(detail)) break;
|
|
}
|
|
}
|
|
if (detail != null)
|
|
{
|
|
detail = detail.Replace("\r", " ").Replace("\n", " ");
|
|
if (detail.Length > 70) detail = detail.Substring(0, 67) + "...";
|
|
return $"[{name}: {detail}]";
|
|
}
|
|
return $"[{name}]";
|
|
}
|
|
}
|
|
}
|