AnyEvent-App-PerlLive

 view release on metacpan or  search on metacpan

lib/AnyEvent/App/PerlLive.pm  view on Meta::CPAN

package AnyEvent::App::PerlLive;

use utf8;
use strict;
use warnings;
use FindBin;
use File::Spec;

our $VERSION = '0.01';

sub script_path {
    my $class = shift;
    my $script = File::Spec->catfile($FindBin::Bin, 'perl-live.pl');

perl-live-mcp.pl  view on Meta::CPAN

#!/usr/bin/env perl
use utf8;
use strict;
use warnings;
use FindBin;
use Cwd qw(abs_path getcwd);
use IPC::Open3 qw(open3);
use Symbol qw(gensym);
use IO::Select;
use Encode qw(encode_utf8 decode_utf8);
use JSON::PP qw(encode_json decode_json);

binmode STDIN, ':raw';
binmode STDOUT, ':raw';
binmode STDERR, ':encoding(UTF-8)';
$| = 1;

my $root_dir = abs_path("$FindBin::Bin");
my $backend_script = $ENV{PERL_LIVE_SCRIPT}
                  // (-f "$root_dir/perl-live.pl" ? "$root_dir/perl-live.pl" : "perl-live.pl");

perl-live-mcp.pl  view on Meta::CPAN

        code => $code . "\n",
        file => $file,
        line => $line,
    });
    my $barrier_req = encode_json({
        code => "print qq(__B_OUT_${token}__\n); warn qq(__B_ERR_${token}__\n);\n",
        file => '(barrier)',
        line => 1,
    });

    my $code_frame = length(encode_utf8($code_req)) . "\n" . encode_utf8($code_req);
    my $barrier_frame = length(encode_utf8($barrier_req)) . "\n" . encode_utf8($barrier_req);

    print {$session_in} $code_frame;
    print {$session_in} $barrier_frame;

    my ($stdout, $stderr) = ('', '');
    my $sel = IO::Select->new($session_out, $session_err);
    my ($got_out, $got_err) = (0, 0);
    my $deadline = time + $timeout;
    my $interrupted = 0;

perl-live-mcp.pl  view on Meta::CPAN

            }
        }

        if (!kill(0, $session_pid)) {
            stop_backend();
            last;
        }
    }

    $session_eval_count++;
    return (decode_utf8($stdout), decode_utf8($stderr), $interrupted);
}

my %tools = (
    perl_live_eval => {
        name => 'perl_live_eval',
        description => 'Evaluate Perl code inside the persistent live interpreter session. Package variables, declared subroutines, and pragmas persist across calls without shell overhead.',
        inputSchema => {
            type => 'object',
            properties => {
                code => {

perl-live.pl  view on Meta::CPAN

#!/usr/bin/env perl
use utf8;
use strict;
use warnings;
use feature qw(say state);
use experimental grep {
    exists $feature::feature{$_} || exists $warnings::Offsets{"experimental::$_"}
} qw(smartmatch switch lexical_subs defer declared_refs refaliasing
     bitwise builtin for_list isa signatures try);
use Encode 'decode_utf8';
use Getopt::Std 'getopts';
use JSON::PP 'decode_json';
use PadWalker 'peek_my';
use Package::Stash ();
use AnyEvent;

$λ::st = Package::Stash->new('main');
$λ::in = {};
getopts('gpj', $λ::in) or die "Usage: perl perl-live.pl [-g] [-p|-j]\n";
binmode STDIN, ':raw';

perl-live.pl  view on Meta::CPAN


# Keep evaluator internals out of the lexical pad exported by peek_my.
sub λ::eval_code {
    $λ::ctx = {};
    $λ::source_file = $_[1] // '(perl live)';
    $λ::file = $λ::source_file;
    # Alias filenames that cannot be represented in a #line directive.
    if ($λ::file =~ /[\r\n]/ || ($λ::file =~ /"/ && $λ::file =~ /(?:\A"|\s)/)) {
        $λ::file = '(perl-live source '.++$λ::file_id.')';
    }
    $λ::files->{Encode::encode_utf8($λ::file)} = $λ::source_file;
    $λ::directive_file = $λ::file =~ /"/ ? $λ::file : qq("$λ::file");
    {
        local $SIG{INT} = sub { die "Evaluation interrupted\n" };
        eval 'BEGIN { ($^H,${^WARNING_BITS},%^H) = @{$λ::hint} if $λ::hint }'
             ."\n#line ".($_[2] // 1)." $λ::directive_file\n"
             .$_[0]
             ."\n; package main; \$λ::ctx = peek_my(0);"
             .'BEGIN { $λ::hint = [$^H,${^WARNING_BITS},%^H] }';
        $λ::error = $@;
    }

perl-live.pl  view on Meta::CPAN

                    || (exists($request->{file})
                        && (!defined($request->{file}) || ref($request->{file})))
                    || (exists($request->{line})
                        && (!defined($request->{line}) || ref($request->{line})
                            || $request->{line} !~ /\A[1-9][0-9]*\z/))) {
                    λ::finish("Invalid evaluation request\n");
                    return;
                }
                λ::eval_code($request->{code}, $request->{file}, $request->{line});
            }
            else { λ::eval_code(decode_utf8($payload)) }
            undef $λ::size;
        }
    }
    elsif (eof(STDIN)) {
        STDIN->clearerr if -t STDIN;
        λ::eval_code(decode_utf8(substr $λ::buf, 0, length $λ::buf, ''));
        λ::finish() unless -t STDIN;
    }
    else {
        my $line = <STDIN>;
        $λ::buf .= $line if defined $line;
    }
};

print "PERL-LIVE READY 1\n" if $λ::in->{j};
$λ::cv->recv;

test/mcp.t  view on Meta::CPAN

use utf8;
use strict;
use warnings;
use Test::More;
use Encode qw(encode_utf8 decode_utf8);
use JSON::PP qw(encode_json decode_json);
use FindBin;
use IPC::Open3;
use IO::Select;
use Symbol qw(gensym);

my $server_script = "$FindBin::Bin/../perl-live-mcp.pl";
my ($in, $out);
my $err = gensym;
my $pid = open3($in, $out, $err, $^X, $server_script);
binmode $_, ':raw' for ($in, $out, $err);

sub rpc_call {
    my ($req) = @_;
    my $json = encode_json($req);
    print {$in} $json . "\n";

    my $line = <$out>;
    die "Server closed stdout unexpectedly\n" unless defined $line;
    return decode_json(decode_utf8($line));
}

my $init_res = rpc_call({
    jsonrpc => '2.0',
    id => 1,
    method => 'initialize',
    params => { protocolVersion => '2024-11-05' }
});
is $init_res->{id}, 1, 'initialize returns matching id';
is $init_res->{result}{serverInfo}{name}, 'perl-live', 'serverInfo name is perl-live';

test/protocol.t  view on Meta::CPAN

use utf8;
use strict;
use warnings;
use Test::More;
use Encode qw(encode_utf8);
use JSON::PP qw(encode_json);
use FindBin;
use IPC::Open3;
use IO::Select;
use Symbol qw(gensym);

my $script = "$FindBin::Bin/../perl-live.pl";

sub run_input {
    my ($input, @switches) = @_;

test/protocol.t  view on Meta::CPAN

                $readers->remove($fh);
                close $fh;
            }
        }
    }
    waitpid $pid, 0;
    return ($?, $stdout, $stderr);
}

sub frame {
    my $source = encode_utf8($_[0] . "\n");
    return length($source) . "\n" . $source;
}

sub request_frame {
    my ($source, $file, $line) = @_;
    my $request = encode_json({
        code => $source,
        file => $file // '(test)',
        line => $line // 1,
    });

test/protocol.t  view on Meta::CPAN

    my ($status, $out, $err) = run_input(
        frame('my $answer = 41;') . frame('print ++$answer, qq(\n);'), '-g', '-p');
    is $status, 0, 'framed input exits after stdin closes';
    is $out, "42\n", 'multiple frames preserve variables';
    is $err, '', 'framed input produces no warnings';
}
{
    my ($status, $out, $err) = run_input(
        frame('print qq(café привет 😀\n);'), '-p');
    is $status, 0, 'Unicode frame exits successfully';
    is $out, encode_utf8("café привет 😀\n"), 'frame lengths and output use UTF-8 bytes';
    is $err, '', 'Unicode output produces no warnings';
}
{
    my ($status, $out, $err) = run_input(encode_utf8('print qq(café\n);'), '-g');
    is $status, 0, 'plain input exits after permanent EOF';
    is $out, encode_utf8("café\n"), 'plain input still evaluates';
    is $err, '', 'plain input produces no warnings';
}
{
    my ($status, $out, $err) = run_input("invalid\n", '-p');
    isnt $status, 0, 'invalid frame header fails';
    like $err, qr/Invalid evaluation frame/, 'invalid header reports the cause';
}
{
    my ($status, $out, $err) = run_input("100\nprint 42;", '-p');
    isnt $status, 0, 'truncated frame fails';

test/protocol.t  view on Meta::CPAN

{
    my $file = '/tmp/source with"quotes\\here.pl';
    my ($status, $out, $err) = run_input(
        request_frame("die 'boom';", $file, 7), '-j');
    like $err, qr/\Q$file\E line 7/, 'source filenames preserve quotes and backslashes';
}
{
    my $file = '/tmp/café привет.pl';
    my ($status, $out, $err) = run_input(
        request_frame("die 'boom';", $file, 9), '-j');
    my $expected = encode_utf8("$file line 9");
    like $err, qr/\Q$expected\E/, 'source filenames preserve Unicode characters';
}
{
    my $file = '/tmp/café привет.pl';
    my ($status, $out, $err) = run_input(
        request_frame("sub fail_later { die 'boom' };", $file, 11)
            . request_frame('fail_later();', '/tmp/caller.pl', 3), '-j');
    my $expected = encode_utf8("$file line 11");
    like $err, qr/\Q$expected\E/, 'errors retain locations from earlier evaluations';
}
{
    my $file = '/tmp/source with"quotes.pl';
    my ($status, $out, $err) = run_input(
        request_frame("warn 'careful';", $file, 5), '-j');
    like $err, qr/\Q$file\E line 5/, 'warnings retain filenames requiring a line-directive alias';
}
{
    my $request = encode_json({ code => 'print qq(café привет 😀\n);', file => '(test)', line => 1 });
    my ($status, $out, $err) = run_input(length($request) . "\n" . $request, '-j');
    is $out, "PERL-LIVE READY 1\n" . encode_utf8("café привет 😀\n"),
        'JSON frames use byte lengths for Unicode source';
    is $err, '', 'Unicode metadata requests produce no warnings';
}
for my $payload ('{', '[]', '{"code":[]}', '{"code":"1","line":0}', '{"code":"1","file":{}}') {
    my ($status, $out, $err) = run_input(length($payload) . "\n" . $payload, '-j');
    isnt $status, 0, 'invalid metadata request fails';
    like $err, qr/Invalid evaluation request/, 'invalid metadata reports the cause';
}

done_testing;



( run in 2.097 seconds using v1.01-cache-2.11-cpan-234fa220139 )