ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/cvsroot/AnyEvent-MCP/lib/AnyEvent/MCP.pm
Revision: 1.24
Committed: Wed Oct 14 14:16:04 2026 UTC (4 weeks, 5 days ago) by root
Branch: MAIN
Changes since 1.23: +7 -5 lines
Log Message:
*** empty log message ***

File Contents

# User Rev Content
1 root 1.1 =head1 NAME
2    
3     AnyEvent::MCP - Model Context Protocol client/server support
4    
5     =head1 SYNOPSIS
6    
7 root 1.15 use AnyEvent::MCP::Server::Simple;
8 root 1.1
9 root 1.21 my %options = mcp_getoptions ...;
10     mcp_tool ...;
11     mcp_start %options;
12 root 1.1
13     or use the object interface directly:
14    
15 root 1.6 use AnyEvent::MCP::Server ();
16 root 1.1
17     my $server = AnyEvent::MCP::Server->new (...);
18    
19     =head1 DESCRIPTION
20    
21 root 1.21 AnyEvent::MCP provides event-driven Model Context Protocol client and server
22     support. There are three starting points:
23    
24     =over
25    
26     =item Use the included servers without writing Perl
27    
28     L<AnyEvent::MCP::Intro> walks through installation, a first filesystem
29     request, client connections, configuration, permissions and combining
30     servers. Start there if you want the tools to work on your projects.
31    
32     =item Write a small MCP server
33 root 1.17
34 root 1.21 L<AnyEvent::MCP::Server::Simple/TUTORIAL> builds a complete server,
35     calls it, and adds options, replies, permission checks and asynchronous
36     work. Simple handles transport startup and the event loop.
37    
38     =item Embed MCP in an application
39    
40     The modules below expose tool registries, protocol dispatch, requests and
41     transports separately, for applications that need to control their own
42     connections or lifetime.
43    
44     =back
45 root 1.1
46     The usual way to implement a small MCP server is
47     L<AnyEvent::MCP::Server::Simple>, which provides a function-based interface and
48     creates the underlying server objects when a transport such as stdio or HTTP is
49     started.
50    
51     The lower-level object interfaces are intended for applications that need to
52     manage MCP connections, servers or reusable tool registries directly.
53    
54     =head2 MODULES
55    
56 root 1.7 =over
57 root 1.1
58     =item L<AnyEvent::MCP::Server::Simple>
59    
60     Function-based interface for implementing ordinary MCP servers.
61    
62     =item L<AnyEvent::MCP::Server>
63    
64     Object-oriented MCP server interface.
65    
66     =item L<AnyEvent::MCP::Client>
67    
68     Object-oriented MCP client interface.
69    
70     =item L<AnyEvent::MCP::Server::Toolset>
71    
72     Reusable registry of MCP tool declarations.
73    
74     =item L<AnyEvent::MCP::Server::Permissions>
75    
76 root 1.21 Action authorization and sandbox-grant handling for MCP servers.
77 root 1.1
78     =back
79    
80 root 1.4 C<mcp-multibroker> combines downstream HTTP and stdio servers under tool-name
81     prefixes. It uses the same client, server and permission helper facilities,
82     including modern input forwarding and local permission prompts for legacy
83     callers. Run C<mcp-multibroker --help> for command-line syntax; its manual
84     describes authentication and configuration.
85    
86 root 1.16 The interfaces are still being designed. L<AnyEvent::MCP::Intro> explains
87     the installed programs; module-specific POD describes their Perl APIs.
88 root 1.9
89 root 1.16 =head1 TUTORIAL
90 root 1.9
91 root 1.21 For using the servers, see L<AnyEvent::MCP::Intro>. It includes a working
92     first connection, a complete configuration example, saved permissions,
93     multibroker setup and troubleshooting.
94    
95     For writing a server, see L<AnyEvent::MCP::Server::Simple/TUTORIAL>.
96     The tutorial starts with a complete echo server and a client that prints
97     its reply, then develops argument validation, command-line options,
98     result representations, permission retries and cancellable asynchronous
99     work. The Simple function reference follows it.
100    
101     For custom dispatch and reusable tool registries, see
102     L<AnyEvent::MCP::Server::Toolset/REQUEST AND TOOL WORKFLOW> and
103     L<AnyEvent::MCP::Server>. The client modules describe calling servers
104     from your own application.
105 root 1.9
106 root 1.1
107 root 1.2 =head1 GLOBAL CONFIGURATION
108    
109     The shared per-user configuration is C<$XDG_CONFIG_HOME/anyevent-mcp/global.ini>,
110     or C<$HOME/.config/anyevent-mcp/global.ini> when XDG_CONFIG_HOME is unset.
111     L<AnyEvent::MCP::Config> loads and holds it; loading this module does not access
112     configuration files.
113    
114     The file is UTF-8 and uses sections with single-line C<key = value> pairs.
115     Values are unquoted strings. Blank lines and whole-line comments beginning
116     with C<#> or C<;> are ignored; inline comment characters remain part of the
117     value. Later occurrences of a key replace earlier ones in the same section.
118    
119     [global]
120     secret = ...128 hexadecimal digits...
121    
122 root 1.18 [instance example]
123 root 1.11 bind = 127.0.0.1:31740
124 root 1.13 tokens = first-token,second-token
125 root 1.2
126 root 1.21 [program mcp-fs]
127     mount.opt = ro:/opt
128 root 1.2
129     Section names are unrestricted. Application-specific sections, including
130     exports, utility paths and user settings, are documented by their applications.
131    
132     C<[global]> holds C<secret>, a 64-byte master key encoded as 128 hexadecimal
133     digits. The file must be owned by the current user, with no group or other
134     permissions. A missing secret is generated automatically on first configuration
135     access and saved when possible. Existing secrets are never replaced implicitly.
136     An invalid secret is an error.
137    
138 root 1.22 Applications can derive their own purpose-specific secrets with
139     L<AnyEvent::MCP::Config/derive_secret>, using the cached global configuration
140     or an explicitly loaded configuration object.
141    
142 root 1.2 If saving fails, Config warns and retains the secret in memory. Credentials
143     then remain stable only for that process; other processes cannot derive the
144     same credentials. If randomness is unavailable, supply a securely generated
145     secret in the file.
146    
147 root 1.24 C<[program PROGRAM]> supplies settings for the invoked program basename;
148     C<[instance NAME]> overrides them for a named instance.
149 root 1.11 HTTP-capable executables use C<--name NAME> to select these settings, with
150 root 1.24 C<default> as the default instance name. Names consist of an ASCII
151 root 1.11 letter or underscore followed by ASCII letters, digits, underscores or
152     hyphens. Their C<--bind ADDRESS[:PORT]> overrides the configured C<bind>.
153 root 1.24 The default bind address is IPv4 loopback with a port derived from the program,
154     instance name and master secret in the range 16384..32767; C<:0> requests an ephemeral
155 root 1.12 port. C<--print-url> prints the URL using the first accepted token without
156     listening. Named server settings also include C<path>, C<url_host>,
157     C<url_scheme> and C<tokens>. C<tokens> is a comma-separated list of
158     URL-safe strings. Repeated C<--token TOKEN> options override this list.
159     All accepted tokens work in the URL path or Authorization bearer header.
160 root 1.24 Without configured tokens, one token is derived from the program and instance
161     name. All derivation contexts have a fixed C<anyevent-mcp> namespace prefix.
162 root 1.11
163 root 1.12 C<mcp_start> resolves named settings and requires the selected token for
164     HTTP requests. Explicit tokens replace the derived default.
165 root 1.11 The low-level HTTP transport does not resolve configuration itself.
166 root 1.21 Simple's stdio startup does not access global HTTP configuration.
167     Applications can still load it for their own settings; C<mcp-fs>, for
168     example, reads trusted mount and executable settings even in stdio mode.
169     Browser origins are permitted by default, but must still pass MCP authentication.
170 root 1.3
171 root 1.12 C<[client NAME]> supplies HTTP client defaults: C<url>, C<bearer> and
172     C<timeout>. Clients consult it only when explicitly given a C<name>.
173 root 1.21 An unnamed HTTP client and the low-level HTTP server do not read global
174     configuration. C<mcp_start> resolves a default name and does read it.
175 root 1.3 Explicit constructor arguments take precedence over named defaults.
176    
177     =head1 ENVIRONMENT
178    
179     Project-specific environment variables use the C<PERL_ANYEVENT_MCP_> prefix.
180     C<PERL_ANYEVENT_MCP_MULTIBROKER_PROTOCOL=stdio> selects stdio in Simple.
181 root 1.11 C<PERL_ANYEVENT_MCP_MULTIBROKER_ALIAS> names a multibroker routing prefix;
182     it does not change the service-instance name.
183 root 1.3 C<PERL_ANYEVENT_MCP_PERMISSION_HELPER> selects the external asking executable.
184 root 1.21 C<PERL_ANYEVENT_MCP_PERMISSION_ASK> selects the permission engine's
185     asking default: C<helper>, C<auto> or C<mcp>. See
186     L<AnyEvent::MCP::Intro/Choose where to ask> for the behavior and client
187     requirements.
188 root 1.3 Standard C<HOME> and C<XDG_CONFIG_HOME> keep their standard names.
189 root 1.2
190     =head1 FUNCTIONS
191    
192 root 1.6 =over
193    
194 root 1.10 =item $class = AnyEvent::MCP::json_class
195    
196     Returns C<JSON::XS> if available, otherwise C<JSON::PP>. The caller
197     configures a new coder instance as needed.
198    
199 root 1.8 =item $bytes = AnyEvent::MCP::utf8enc $text
200    
201     Return a UTF-8 byte string for C<$text>, leaving the argument unchanged.
202    
203     =item $text = AnyEvent::MCP::utf8dec $bytes
204    
205     Decode a UTF-8 byte string into characters, dying on invalid UTF-8.
206     The argument is left unchanged. For intentional in-place conversions,
207     use Perl's C<utf8::encode> or C<utf8::decode> directly.
208    
209 root 1.6 =item $bytes = AnyEvent::MCP::random_bytes $length
210 root 1.2
211     Returns exactly C<$length> random bytes. Tries C</dev/urandom>, then an external
212     C<openssl rand> command. No additional random-number module is required.
213     Dies if neither source supplies the requested bytes successfully.
214     C<$length> must be a nonnegative integer; zero returns an empty string.
215    
216 root 1.6 =back
217    
218     =head2 PATCH UTILITIES
219    
220 root 1.7 Since applying patches to files is a common task for MCP servers, the
221 root 1.6 following utility functions can be used to ease that job. Together, they
222 root 1.7 define a common patch format (unified diff or a simplified version of it,
223     with fewer requirements to make it easier for the LLM to generate), helpers
224 root 1.6 to apply the patch and a helper to verify if the patch was applied
225     with sufficient precision.
226    
227 root 1.7 Use C<apply_udiff> to normalize, apply and validate a patch in one operation.
228     It writes a separate output file; the caller checks freshness and metadata
229     and commits the result.
230    
231     For an application-specific applier, the workflow is:
232 root 1.6
233     =over
234    
235     =item 1. AnyEvent::MCP::normalize_udiff
236    
237 root 1.7 Returns a unified diff for GNU patch and the permitted hunk offsets.
238    
239     =item 2. Apply the normalized diff
240 root 1.6
241 root 1.7 Run GNU patch with fuzz zero and capture its verbose output.
242 root 1.6
243 root 1.7 =item 3. AnyEvent::MCP::check_patch_output
244    
245     Checks the process status and output against the permitted offsets.
246     C<parse_patch_output> is available separately when only parsing is needed.
247 root 1.5
248 root 1.6 =back
249    
250 root 1.5 =head3 Input format
251    
252 root 1.6 The patch format accepted by normalize_udiff is an extension to the
253     (essentially undocumented) unified diff format.
254    
255 root 1.5 In a hunk header, only the old start C<-N> matters. It is the old-file line
256     of the first hunk body line, including context, not necessarily the first
257     changed line. Counts and the new-file position are ignored and recomputed.
258     Both ordinary headers and the abbreviated form are accepted:
259    
260     @@ -42,99 +123,99 @@
261     @@ -42 @@
262    
263     Optional text after the closing C<@@> is preserved. File headers and other
264     text before the first hunk are preserved; a diff must describe one file.
265    
266     Hunk body lines use the usual prefixes: a space for unchanged context,
267     C<-> for removed lines and C<+> for added lines. The
268     C<\ No newline at end of file> marker is preserved and counts neither side.
269     Trailing empty lines outside the final hunk are discarded.
270    
271 root 1.7 Pure insertion is permitted only at the beginning, using old start C<0>.
272     For example, C<@@ -0 @@> with one added line becomes C<@@ -0,0 +1,1 @@>.
273     An empty old-side range names the line before the insertion: C<-0,0>
274     means before line 1, whereas C<-1,0> would mean after line 1 and is rejected
275     here. Nonempty ranges use one-based line numbers.
276    
277 root 1.5 An insertion elsewhere needs old-side context. Empty hunks are rejected.
278     New positions include the cumulative line-count changes of preceding hunks.
279    
280     =head3 Applying the result
281    
282 root 1.6 The C<normalize_udiff> function does not apply the patch, check file
283     contents or guard against concurrent edits. The caller must supply those
284     checks, if required.
285 root 1.5
286     Context must match exactly: apply with fuzz zero. For each hunk,
287     C<$max_offset> permits relocation by at most the number of distinct old-side
288     lines minus one, or zero for a pure insertion. Repeated old-side lines do
289     not increase this allowance. The applier must enforce these limits; an
290     unrestricted search for matching context can select the wrong occurrence.
291    
292     For live Vim buffers, also require the expected changedtick to match.
293     File-based users need an equivalent check before replacing the file.
294    
295 root 1.6 To work around GNU patch's handling of asymmetric context, the
296     first context line of each hunk is rewritten as an identity
297     removal/addition. The line contents and old/new line counts are
298     unchanged. This is normalization for the patch applier, not a relaxation
299     of context matching.
300 root 1.5
301 root 1.6 =over
302    
303     =item ($diff, $max_offset) = AnyEvent::MCP::normalize_udiff $diff
304    
305     Normalizes a relaxed, single-file unified diff into ordinary unified diff
306     syntax. Returns the normalized C<$diff> and an array reference C<$max_offset>
307     containing the permitted whole-hunk relocation for each hunk, in order.
308     Dies on malformed hunks or when no hunks are found.
309    
310     Here is a suitable description for the diff format, e.g. in a tool
311     definition:
312    
313     Apply a unified diff to one regular file. Hunk counts are recomputed,
314     fuzz is disabled, whole-hunk relocation is limited per hunk by distinct
315     old-side lines. Pure insertion is allowed only at the beginning;
316     elsewhere include old-side context.
317    
318     =item $cv = AnyEvent::MCP::apply_udiff $input, $output, $diff
319    
320     Asynchronously applies the relaxed C<$diff> to the input file C<$input>,
321     writing a separate output file C<$output>. C<$diff> must contain bytes;
322     callers working with characters must encode them for the file themselves.
323    
324     Normalizes the diff, runs GNU patch using C<AnyEvent::Util::run_cmd>, and
325     validates its verbose output with C<check_patch_output>. The command uses
326     batch/forward mode, binary mode and fuzz zero. No shell is involved.
327    
328     C<$output> must not exist. It is reserved with mode 0600; patch runs in its
329     directory so incidental temporary files stay there. Input and output paths
330     are made absolute before starting the command. These must be trusted paths
331     in a directory controlled by the caller.
332    
333     Returns a condition variable. Its C<recv> returns the validated hunk array
334     reference, or throws on command/application failure. Setup failures throw
335     synchronously. Failed or partial output is removed. C<$input> is unchanged.
336    
337     The caller owns committing the successful output and removing it when no
338     longer needed. Freshness checks, metadata preservation, atomic replacement
339     and application-specific permissions also belong to the caller.
340    
341     For your reference, the exact options used are:
342    
343     --verbose --batch --forward --binary --fuzz=0
344     --no-backup-if-mismatch
345     --reject-file=- --output=... -- <inputfile>
346    
347     =item $parsed = AnyEvent::MCP::parse_patch_output $output
348 root 1.5
349     Parses C<LC_ALL=C> GNU patch C<--verbose> output without judging whether
350     the application is acceptable. C<$parsed> has two fields:
351    
352 root 1.6 =over
353 root 1.5
354     =item hunks => [$hunk...]
355    
356     Hunk records in output order. Each record contains C<hunk> (the one-based
357     number), C<success>, C<line> (the reported application line), C<fuzz> and
358     the signed C<offset>. Omitted fuzz and offset are zero. Failed and ignored
359     hunks have false C<success>.
360    
361     =item unparsed => [$line...]
362    
363     Lines not recognized as hunk results or GNU patch's verbose framing.
364     The parser preserves them for callers to interpret or reject.
365    
366     =back
367    
368     Use verbose output: ordinary patch output omits exact-position successes,
369     so it cannot account for every hunk.
370    
371 root 1.6 =item $hunks = AnyEvent::MCP::check_patch_output $status, $output, [$max_offset...]
372 root 1.5
373     Parses C<$output> and validates a complete application. C<$status> is the
374     raw process wait status, as returned by C<waitpid> or
375     C<AnyEvent::Util::run_cmd>, not just the exit code.
376    
377     Requires status zero, no unrecognized output, exactly the expected hunks
378     in numbered order, successful application, fuzz zero and each signed offset
379     within its corresponding absolute limit. C<[$max_offset...]> is the array
380     reference returned by C<normalize_udiff>. At least one hunk is required.
381    
382     Returns the parsed hunk array reference on success; otherwise dies with a
383     diagnostic. This is also suitable for callers running patch inside their
384     own sandbox.
385    
386 root 1.6 =back
387 root 1.5
388 root 1.1 =cut
389    
390     package AnyEvent::MCP;
391    
392     use common::sense;
393    
394     our $VERSION = '0.0';
395    
396 root 1.10 sub json_class {
397     our $JSON_CLASS ||= eval { require JSON::XS; "JSON::XS" }
398     || do { require JSON::PP; "JSON::PP" };
399     }
400    
401 root 1.8 sub utf8enc($) {
402     my $text = shift;
403    
404     utf8::encode $text;
405     $text
406     }
407    
408     sub utf8dec($) {
409     my $bytes = shift;
410    
411     utf8::decode $bytes
412     or die "invalid UTF-8\n";
413     $bytes
414     }
415    
416 root 1.2 sub random_bytes($) {
417     my ($length) = @_;
418    
419 root 1.19 defined $length && $length =~ /\A[0-9]+\z/
420     or die "Invalid random byte count\n";
421 root 1.2 return "" unless $length;
422    
423     my $bytes = "";
424    
425     if (open my $fh, "<", "/dev/urandom") {
426     binmode $fh;
427     while (length $bytes < $length) {
428     read ($fh, $bytes, $length - length ($bytes), length $bytes)
429     or last;
430     }
431     close $fh;
432    
433     return $bytes if length $bytes == $length;
434     }
435    
436     if (open my $fh, "-|", "openssl", "rand", $length) {
437     binmode $fh;
438     local $/;
439     $bytes = <$fh>;
440     my $success = close $fh;
441    
442     return $bytes
443     if $success && defined $bytes && length $bytes == $length;
444     }
445    
446     die "Cannot obtain $length random bytes from /dev/urandom or openssl rand\n";
447     }
448    
449 root 1.5 sub normalize_udiff {
450     my $diff = shift;
451     my @line = split /\n/, $diff, -1;
452     my $delta = 0;
453     my $hunks = 0;
454     my @max_offset;
455    
456     pop @line while @line and !length $line[-1];
457    
458     for (my $i = 0; $i < @line; ++$i) {
459     next unless $line[$i] =~ /^@@ /;
460    
461     $line[$i] =~ /^@@ -(\d+)(?:,\d+)?(?: \+\d+(?:,\d+)?)? @@(.*)$/
462     or die "normalize_udiff: bad hunk header '$line[$i]'\n";
463    
464     my ($old_start, $suffix) = ($1, $2);
465     my ($old_count, $new_count) = (0, 0);
466     my %old_line;
467     my $j = $i + 1;
468    
469     # GNU patch mishandles hunks with more prefix than suffix context.
470     # Make the first context line an identity change without losing it.
471     # see https://unix.stackexchange.com/questions/414542/does-patch-work-with-asymmetric-context
472     splice @line, $i + 1, 1, "-$1", "+$1"
473     if $line[$i + 1] =~ /^ (.*)\z/;
474    
475     for (; $j < @line; ++$j) {
476     last if $line[$j] =~ /^@@ /;
477    
478     my $tag = substr $line[$j], 0, 1;
479    
480     if ($tag eq " ") {
481     ++$old_count;
482     ++$new_count;
483     $old_line{substr $line[$j], 1} = 1;
484     } elsif ($tag eq "-") {
485     ++$old_count;
486     $old_line{substr $line[$j], 1} = 1;
487     } elsif ($tag eq "+") {
488     ++$new_count;
489     } elsif ($line[$j] eq "\\ No newline at end of file") {
490     # Marker belongs to the preceding body line and counts neither side.
491     } else {
492     die "normalize_udiff: bad hunk line '$line[$j]'\n";
493     }
494     }
495    
496     $old_count or $new_count
497     or die "normalize_udiff: empty hunk at old line $old_start\n";
498    
499     $old_count or !$old_start
500     or die "normalize_udiff: hunk " . ($hunks + 1)
501     . " needs old-side context for insertion after old line $old_start\n";
502    
503     my $new_start = $old_start + $delta;
504     ++$new_start unless $old_count;
505     --$new_start unless $new_count;
506    
507     $new_start >= 0
508     or die "normalize_udiff: invalid new line $new_start\n";
509    
510     $line[$i] = sprintf "@@ -%d,%d +%d,%d @@%s",
511     $old_start, $old_count, $new_start, $new_count, $suffix;
512    
513     $delta += $new_count - $old_count;
514     ++$hunks;
515     my $max_offset = keys %old_line;
516     --$max_offset
517     if $max_offset;
518     push @max_offset, $max_offset;
519     $i = $j - 1;
520     }
521    
522     $hunks
523     or die "normalize_udiff: no hunks\n";
524    
525     (join ("\n", @line, ""), \@max_offset)
526     }
527    
528     sub parse_patch_output {
529     my ($output) = @_;
530     my (@hunks, @unparsed);
531    
532     for (split /\n/, $output) {
533     if (/^Hunk #(\d+) (succeeded|FAILED|ignored) at (-?\d+)(?: with fuzz (\d+))?(?: \(offset (-?\d+) lines?\))?\.\z/) {
534     push @hunks, {
535     hunk => 0 + $1,
536     success => $2 eq "succeeded",
537     line => 0 + $3,
538     fuzz => 0 + $4,
539     offset => 0 + $5,
540     };
541     } elsif (!length
542     || /^Hmm\.\.\. +Looks like a unified diff to me\.\.\.\z/
543     || /^The text leading up to this was:\z/
544     || /^-+\z/ || /^\|/
545     || /^patching file / || /^checking file /
546     || /^Using Plan [AB]\.\.\.\z/ || /^done\z/) {
547     # GNU patch --verbose framing, not hunk results.
548     } else {
549     push @unparsed, $_;
550     }
551     }
552    
553     { hunks => \@hunks, unparsed => \@unparsed }
554     }
555    
556     sub check_patch_output {
557     my ($status, $output, $max_offset) = @_;
558     my $parsed = parse_patch_output $output;
559     my $hunks = $parsed->{hunks};
560    
561     die "patch failed (wait status $status):\n$output"
562     if $status;
563     die "patch: unrecognized output:\n" . (join "\n", @{$parsed->{unparsed}}) . "\n"
564     if @{$parsed->{unparsed}};
565     die "patch: expected " . @$max_offset . " hunks, got " . @$hunks . "\n"
566     unless @$hunks == @$max_offset && @$hunks;
567    
568     for my $i (0 .. $#$hunks) {
569     my $hunk = $hunks->[$i];
570    
571     die "patch: unexpected hunk number $hunk->{hunk}\n"
572     unless $hunk->{hunk} == $i + 1;
573     die "patch: hunk $hunk->{hunk} failed\n"
574     unless $hunk->{success};
575     die "patch: hunk $hunk->{hunk} used fuzz $hunk->{fuzz}\n"
576     if $hunk->{fuzz};
577     die "patch: hunk $hunk->{hunk} offset $hunk->{offset} exceeds $max_offset->[$i]\n"
578     if abs $hunk->{offset} > $max_offset->[$i];
579     }
580    
581     $hunks
582     }
583    
584     sub apply_udiff {
585     my ($input, $output, $diff) = @_;
586     my ($normalized, $max_offset) = normalize_udiff $diff;
587    
588     require AnyEvent::Util;
589     require File::Spec;
590     require File::Basename;
591     require Fcntl;
592    
593     $input = File::Spec->rel2abs ($input);
594     $output = File::Spec->rel2abs ($output);
595     my $directory = File::Basename::dirname ($output);
596    
597     sysopen my $fh, $output, Fcntl::O_WRONLY () | Fcntl::O_CREAT () | Fcntl::O_EXCL (), 0600
598     or die "$output: $!\n";
599     close $fh or do { my $error = $!; unlink $output; die "$output: $error\n" };
600    
601     my $cv = AE::cv ();
602     my $log;
603     my $process = eval {
604     AnyEvent::Util::run_cmd ([
605     "patch", "--verbose", "--batch", "--forward", "--binary", "--fuzz=0",
606     "--no-backup-if-mismatch", "--reject-file=-", "--output=$output", "--", $input,
607     ],
608     "<" => \$normalized,
609     ">" => \$log,
610     close_all => 1,
611     on_prepare => sub {
612     $ENV{LC_ALL} = "C";
613     chdir $directory or die "$directory: $!\n";
614     defined POSIX::dup2 (1, 2) or die "dup2: $!\n";
615     },
616     );
617     };
618    
619     if ($@) {
620     my $error = $@;
621     unlink $output;
622     die $error;
623     }
624    
625     $process->cb (sub {
626     my $hunks;
627     eval { $hunks = check_patch_output $_[0]->recv, $log, $max_offset; 1 } or do {
628     my $error = $@;
629     unlink $output;
630     $cv->croak ($error);
631     return;
632     };
633    
634     $cv->send ($hunks);
635     });
636    
637     $cv
638     }
639    
640 root 1.1 sub _clean_text($) {
641     my ($text) = @_;
642    
643     my ($prefix) = (join "\n", grep /\S/, split /\n/, $text)
644     =~ /\A([ \t]*)[^\n]*(?:\n\1[^\n]*)*\z/;
645    
646     $text =~ s/^\Q$prefix\E//mg;
647     $text =~ s/\A\s+//;
648     $text =~ s/\s+\z//;
649     $text
650     }
651    
652     package AnyEvent::MCP::Base;
653    
654     sub new {
655     my ($class, %kv) = @_;
656 root 1.19
657 root 1.1 bless \%kv, $class
658     }
659    
660     sub event {
661     my ($self, $event, @args) = @_;
662 root 1.19
663 root 1.1 ($self->{"on_$event"} or return)->($self, @args)
664     }
665    
666     =head1 SEE ALSO
667    
668 root 1.16 L<AnyEvent::MCP::Intro>, L<AnyEvent::MCP::Server::Simple>,
669 root 1.23 L<AnyEvent::MCP::Helper>, L<mcp-ask-user>, L<anyevent-mcp-form-elicitation>,
670 root 1.1 L<AnyEvent>, L<https://modelcontextprotocol.io/>
671    
672     =head1 AUTHOR
673    
674     The main author of this module is OpenAI ChatGPT.
675    
676     Additional guidance received by:
677    
678     Marc Lehmann <schmorp@schmorp.de>
679     http://home.schmorp.de/
680    
681     =cut
682    
683     1
684