Developer-Dashboard
view release on metacpan or search on metacpan
the existing Ajax temp cleanup
- recorded hashed temp-state runtime metadata under the shared `/tmp`
state tree so stale temp roots can be identified safely and active
DD-OOP-LAYERS state roots are preserved
- added focused unit and CLI smoke coverage for built-in housekeeper
cleanup, helper staging, and collector execution
2.40 2026-04-16
- taught executable hook files with a `.go` suffix to run through
`go run` while keeping the normal hook ordering, RESULT chaining, and
stdout/stderr streaming behavior
- taught executable hook files with a `.java` suffix to compile through
`javac` into an isolated temp directory and then run through `java`
using the declared main class from the source file
- taught direct `dashboard <command>` lookup to resolve executable
`cli/<command>.go` and `cli/<command>.java` source commands
- added focused platform coverage plus CLI smoke coverage for Go and Java
hook launch paths, with live smoke cases running when the corresponding
toolchains are available on the host
2.38 2026-04-15
- added `singleton => 'NAME'` support to saved bookmark `Ajax(...)` helpers, emitting `/ajax/<file>?type=...&singleton=NAME` so browser refreshes can replace older long-running Perl ajax workers cleanly
- renamed singleton-managed saved Ajax Perl workers to `dashboard ajax: NAME` and reused `_pkill_perl` before launching a replacement stream, preventing stale refresh-driven background workers from accumulating
- extended web and helper-compatibility coverage for singleton Ajax urls, singleton process titles, and refresh-safe saved Ajax replacement behaviour
1.14 2026-04-02
- updated the GitHub Actions workflows to use `actions/checkout@v5` and opt JavaScript actions into Node 24, removing the hosted-runner deprecation path for the previous Node 20 checkout runtime
- closed the remaining `lib/` coverage gaps in `Developer::Dashboard::Web::App`, `Developer::Dashboard::Web::DancerApp`, and `Developer::Dashboard::RuntimeManager`, bringing the reviewed Devel::Cover report back to 100% statement and subroutine c...
- fixed runtime web-process detection so `dashboard serve logs ...` and `dashboard serve workers ...` helper commands are no longer misdetected as managed web servers during shutdown and restart scans
1.13 2026-04-02
- extended `dashboard serve logs` with `-n N` tailing and `-f` follow mode, so users can start from the last requested lines and continue streaming appended Dancer2 and Starman log output live
- added runtime-manager and CLI regressions for tailed and followed web logs
- updated README, main POD, architecture docs, and release metadata for the 1.13 log-tail follow release
1.12 2026-04-02
- added `dashboard serve logs` so users can print the combined Dancer2 and Starman runtime log without hunting for the dashboard log file manually
- added configurable Starman worker counts through `dashboard serve workers N`, plus one-off `dashboard serve --workers N` and `dashboard restart --workers N` overrides
- updated README, main POD, architecture docs, and release metadata for the 1.12 web-log and worker-control release
1.11 2026-04-02
- fixed saved bookmark Ajax Perl wrappers to enable autoflush on `STDOUT` and `STDERR`, so long-running handlers that only `print` and `sleep` now stream visible browser output immediately instead of stalling behind process buffering
- extended the blank-environment integration runner to exercise a long-running saved `/ajax/...` stream and assert that the first chunks arrive on time through the installed browser-facing route
- updated README, POD, testing docs, fixed-bug notes, and release metadata for the 1.11 saved-ajax streaming release
1.10 2026-04-02
- changed saved bookmark Ajax helpers and `/ajax/<file>` routes to default to `text/plain` output when no explicit `type => ...` or `?type=...` is supplied
- fixed the Dancer2 ajax bridge so streamed `/ajax/...` responses flush through the HTTP layer instead of being buffered into one final string
- extended ajax helper, web-route, and streaming coverage and updated README, POD, bug notes, and release metadata for the 1.10 ajax-default and streaming fix
1.09 2026-04-02
- fixed transient `/?mode=render&token=...` play for named bookmarks so shared `nav/*.tt` fragments keep the saved `/app/<id>` current-page context instead of collapsing to `/`
- added a dedicated bookmark play regression test for shared nav rendering on both unnamed transient play and named bookmark token play
- updated README, POD, fixed-bug notes, and release metadata for the 1.09 nav-context fix
1.08 2026-04-02
- added `integration/browser/run-bookmark-browser-smoke.pl` for fast host-side browser verification of saved bookmark files, including page-source, ajax, and final DOM assertions
- documented the new bookmark browser smoke workflow in README, main POD, testing docs, and the integration plan so bookmark regressions get a dedicated repro path before the slower blank-environment cycle
- updated release metadata and release-sensitive tests for the 1.08 bookmark browser smoke tooling release
0.99 2026-04-01
- moved saved bookmark `Ajax(file => ...)` storage into `.developer-dashboard/dashboards/ajax/...`, so named handlers live under the saved bookmark tree instead of the runtime cache
- changed saved bookmark `Ajax(file => ...)` calls without `code => ...` to point at an existing executable in that ajax tree instead of overwriting it with an empty generated file
- changed transient-url-disabled saved bookmark Ajax endpoints to emit `/ajax/<file>?type=...` and resolve files directly from the shared dashboards ajax tree
- fixed saved Ajax stream draining so closed-handle comparisons stop emitting uninitialized-value warnings during coverage and process-backed ajax runs
- extended unit, metadata, and blank-environment integration coverage for the dashboards ajax-tree location and existing-file execution flow
0.98 2026-04-01
- changed saved bookmark `/ajax?page=...&file=...` handlers to execute the stored runtime-cache file as a real process, defaulting to Perl unless the file starts with a shebang
- streamed both saved-handler `stdout` and `stderr` back to the browser directly, so `print`, `warn`, `die`, `system`, and `exec` behave like the old playground progress stream instead of a buffered JSON-style response
- extended unit, metadata, and blank-environment integration coverage for process-backed ajax streaming and shebang-backed saved handlers
0.97 2026-04-01
- changed older `/ajax` execution to run bookmark Ajax Perl code directly and stream raw output chunks back to the browser instead of buffering through a page render pass
- changed saved bookmark `Ajax file => ...` handlers to preserve live browser progress updates while transient token urls remain disabled by default
- extended app, server, metadata, and coverage tests for streamed `/ajax` responses and saved bookmark file handlers
0.96 2026-04-01
- changed saved bookmark `Ajax` helper calls to support explicit `file => 'name.json'` routes, storing the handler code under the runtime cache and emitting `/ajax?page=...&file=...` endpoints that stay usable while transient token urls are disab...
- kept transient `/ajax?token=...` support for transient pages behind the existing transient-url opt-in, while making saved bookmark ajax handlers work under the default deny policy
- extended unit, metadata, and blank-environment integration coverage for saved bookmark Ajax file routing
dashboard docker disable green
dashboard docker enable green
```
The resolver also supports old-style isolated service folders without adding entries to dashboard JSON config. If `./.developer-dashboard/docker/green/compose.yml` exists in the current project it wins; otherwise the resolver falls back to `~/.develo...
To toggle that marker without creating or deleting the file manually, use `dashboard docker disable <service>` or `dashboard docker enable <service>`. The toggle writes to the deepest runtime docker root, so a child project layer can locally disable ...
To inspect the effective marker state without walking the folders manually, use `dashboard docker list`. Add `--disabled` to show only disabled services or `--enabled` to show only enabled services.
During compose execution the dashboard exports `DDDC` as the effective config-root docker directory for the current runtime, so compose YAML can keep using `${DDDC}` paths inside the YAML itself.
Wrapper flags such as `--service`, `--addon`, `--mode`, `--project`, and `--dry-run` are consumed first, and all remaining docker compose flags such as `-d` and `--build` pass straight through to the real `docker compose` command.
Without `--dry-run`, the dashboard hands off with `exec`, so you see the normal streaming output from `docker compose` itself instead of a dashboard JSON wrapper.
### Prompt Integration
Render prompt text directly:
```bash
dashboard ps1 --jobs 2
```
`dashboard ps1` now follows the original `~/bin/ps1` shape more closely: a
bin/dashboard view on Meta::CPAN
my $stream = $cmd eq 'doctor' ? 0 : 1;
my %results;
for my $hook_root (@hook_roots) {
opendir my $dh, $hook_root or next;
for my $entry ( sort grep { $_ ne '.' && $_ ne '..' } readdir $dh ) {
my $path = File::Spec->catfile( $hook_root, $entry );
next if !is_runnable_file($path);
next if $entry eq 'run';
my $hook_result = _run_command_hook_streaming(
$path,
stream => $stream,
argv => \@argv,
);
my $result_key = exists $results{$entry} ? _command_hook_result_key($path) : $entry;
$results{$result_key} = {
stdout => $hook_result->{stdout},
stderr => $hook_result->{stderr},
};
$results{$result_key}{exit_code} = $hook_result->{exit_code} if defined $hook_result->{exit_code};
bin/dashboard view on Meta::CPAN
Developer::Dashboard::EnvAudit->clear();
my $paths = Developer::Dashboard::PathRegistry->new(
home => $ENV{HOME},
workspace_roots => [],
project_roots => [],
);
Developer::Dashboard::EnvLoader->load_runtime_layers( paths => $paths );
return 1;
}
# _run_command_hook_streaming($path, %args)
# Executes one hook file, streams its output live, and captures stdout/stderr so
# later hooks and the final command can inspect RESULT JSON.
# Input: executable hook path plus an optional stream flag and argv array ref.
# Output: hash reference containing stdout, stderr, and exit_code.
sub _run_command_hook_streaming {
my ( $path, %args ) = @_;
my $stream = exists $args{stream} ? $args{stream} : 1;
my @argv = @{ $args{argv} || [] };
open my $stdin, '<', File::Spec->devnull() or die "Unable to open " . File::Spec->devnull() . " for hook stdin: $!";
my $stderr = gensym();
my $stdout;
my @command = command_argv_for_path($path);
my $pid = open3( $stdin, $stdout, $stderr, @command, @argv );
close $stdin;
doc/integration-test-plan.md view on Meta::CPAN
- encoding: `dashboard encode`, `dashboard decode`
- indicators: `dashboard indicator set`, `dashboard indicator list`, `dashboard indicator refresh-core`
- collectors: `dashboard collector write-result`, `run`, `list`, `job`, `status`, `output`, `inspect`, `log`, `start`, `restart`, `stop`
- config: `dashboard config init`, `dashboard config show`
- auth: `dashboard auth add-user`, `list-users`, `remove-user`
- pages: `dashboard page new`, `save`, `list`, `show`, `encode`, `decode`, `urls`, `render`, `source`
- actions: `dashboard action run system-status paths`
- docker resolver: `dashboard docker compose --dry-run`
- web lifecycle: `dashboard serve`, `dashboard restart`, `dashboard stop`
- browser checks: headless Chromium editor, saved fake-project bookmark page, outsider bootstrap DOM verification, and helper-login DOM verification after helper-user enablement
- ajax streaming: installed long-running `/ajax/<file>` route timing, early-chunk verification, refresh-safe singleton replacement, `fetch_value()` / `stream_value()` DOM helper coverage, and browser pagehide cleanup coverage in unit tests
- windows verification assets: `integration/windows/run-strawberry-smoke.ps1` and `integration/windows/run-qemu-windows-smoke.sh`
When a release changes the skills runtime, also run the focused host-side
skill regressions outside the blank-container harness:
- `prove -lv t/19-skill-system.t`
- `prove -lv t/20-skill-web-routes.t`
- `prove -lv t/09-runtime-manager.t`
Those focused skill checks currently verify the installed-skill command and
doc/integration-test-plan.md view on Meta::CPAN
17. Restart the installed runtime with one intentionally broken Perl config collector and one healthy config collector, then verify the broken collector reports an error without stopping the healthy collector or its green indicator state, even when p...
18. Exercise page create/save/show/encode/decode/render/source flows inside the fake bookmark directory.
19. Exercise builtin action execution.
20. Exercise docker compose dry-run resolution against a temporary project.
21. Start the installed web service.
22. Confirm exact-loopback access reaches the editor page in Chromium.
23. Confirm the browser can render a saved fake-project bookmark page from the fake project bookmark directory.
24. Confirm the browser inserts sorted rendered `nav/*.tt` bookmark fragments between the top chrome and the main page body.
25. Confirm the browser top-right status strip shows configured collector icons, not collector names, that UTF-8 icons such as `ðŸ³` and `💰` are visibly rendered, and that renamed collectors no longer leave stale managed indicators behind.
26. Confirm an installed saved bookmark page can declare `var endpoints = {};`, then use `fetch_value()` and `stream_value()` from `$(document).ready(...)` against saved `/ajax/<file>` routes without inline-script ordering failures or browser console...
27. Confirm an installed long-running saved `/ajax/<file>` route starts streaming the first output chunks promptly instead of buffering until the worker exits.
28. Confirm non-loopback self-access returns `401` with an empty body and without a login form before any helper user exists in the active runtime.
29. Add a helper user for the outsider browser flow, then confirm non-loopback self-access reaches the helper login page in Chromium.
30. Log in as a helper through the HTTP helper flow.
31. Confirm helper page chrome shows `Logout`.
32. Log out and confirm the helper account is removed.
33. Restart the installed runtime from the extracted tarball tree and confirm the web service comes back.
34. Stop the runtime and confirm the web service is gone.
## Expected Results
doc/testing.md view on Meta::CPAN
--expect-ajax-path /ajax/foobar?type=text \
--expect-ajax-body 123 \
--expect-dom-fragment '<span class="display">123</span>'
```
For long-running saved bookmark Ajax handlers that would otherwise survive a
browser refresh, prefer `Ajax(..., singleton => 'NAME', ...)`. The runtime will
rename the Perl worker to `dashboard ajax: NAME`, terminate the older matching
Perl stream before it starts the refreshed one, and also tear down matching
singleton workers during `dashboard stop`, `dashboard restart`, and browser
`pagehide` cleanup beacons. For browser streaming checks, use `stream_data()`
or `stream_value()` against a finite saved Ajax handler and assert the final
DOM after incremental chunks land.
## Coverage
Install Devel::Cover in a local Perl library and generate the coverage report:
```bash
cpanm --notest --local-lib-contained ./.perl5 Devel::Cover
export PERL5LIB="$PWD/.perl5/lib/perl5${PERL5LIB:+:$PERL5LIB}"
doc/testing.md view on Meta::CPAN
The integration flow also:
- creates a fake project with its own `./.developer-dashboard` runtime tree
- creates that fake-project runtime tree only after `cpanm` completes, so the tarball's own test phase still runs against a clean runtime
- verifies installed CLI and saved bookmarks from that fake project's local runtime plus config collectors from that same runtime root
- verifies `dashboard version` reports the installed runtime version
- seeds a user-provided fake-project `./.developer-dashboard/cli/update` command plus `update.d` hooks inside the container and verifies `dashboard update` uses the same executable command-hook path as every other top-level subcommand, including late...
- verifies the installed web app denies `/?token=...` browser execution by default while saved bookmark routes still render
- uses headless Chromium to validate the editor, the saved fake-project bookmark page, and the helper login page
- verifies that an installed long-running saved `/ajax/...` route starts streaming visible output within the expected first seconds instead of buffering until process exit
- should be interpreted together with the tracked source-tree integration assets in `doc/integration-test-plan.md`, `doc/windows-testing.md`, and `integration/browser/run-bookmark-browser-smoke.pl`; source-tree tests now fail if those release/support...
## Windows Verification
For Windows-targeted changes, keep the verification layered:
- run the fast forced-Windows unit coverage in `t/`
- run the real Strawberry Perl smoke on a Windows host with `integration/windows/run-strawberry-smoke.ps1`
- run the full-system QEMU guest smoke with `integration/windows/run-host-windows-smoke.sh` before making a release-grade Windows compatibility claim
doc/update-and-release.md view on Meta::CPAN
chmod +x ~/.developer-dashboard/cli/update.d/01-runtime
perl -Ilib bin/dashboard update
```
This executes ordered scripts from either `~/.developer-dashboard/cli/update`
or `~/.developer-dashboard/cli/update.d`:
1. sorted by filename
2. running any regular executable file
3. skipping non-executable files
4. streaming each hook file's stdout and stderr live while still accumulating `RESULT` JSON
5. rewriting `RESULT` after each hook so later hook files can react to earlier output
6. passing the final `RESULT` JSON to the real command
`dashboard update` has no special built-in path. If you want it, provide it as
a normal user command and let its hook files run through the same top-level
command-hook path as every other dashboard subcommand.
Perl hook scripts can use `Developer::Dashboard::Runtime::Result` to decode `RESULT` and read
structured hook output without hand-parsing the JSON blob. If the final Perl
command wants a compact summary after the hook chain finishes, it can call
doc/update-and-release.md view on Meta::CPAN
- the local server adds CSP, frame-deny, nosniff, no-referrer, and no-store headers
The extension layer now includes:
- config-backed provider pages resolved through the page resolver
- action execution through the page action runner
- user CLI hook directories under `~/.developer-dashboard/cli`
- project-aware Docker Compose resolution through `dashboard docker compose`
Compose setup can now stay isolated in service folders under `./.developer-dashboard/docker/<service>/compose.yml` for the current project, with `~/.developer-dashboard/config/docker/<service>/compose.yml` as the fallback. The wrapper infers service ...
Without `--dry-run`, the wrapper now hands off with `exec`, so terminal users see the normal streaming output from `docker compose` itself instead of a dashboard JSON wrapper.
Path aliases can now be managed from the CLI with `dashboard path add <name> <path>` and `dashboard path del <name>`. These commands persist user-defined aliases in the effective config root, using a project-local `./.developer-dashboard` tree first ...
Use `Developer::Dashboard::Folder` for runtime path helpers. It resolves the
same root-style names exposed by `dashboard paths`, including runtime,
bookmark, config, and configured alias names such as `docker`, without relying
on unscoped CPAN-global module names.
`dashboard init` now seeds `api-dashboard` and `sql-dashboard` as editable saved bookmarks when those ids are missing. Re-running init keeps existing user config intact, creates `config.json` as `{}` only when it is missing, keeps dashboard-managed h...
`dashboard cpan <Module...>` now manages optional runtime Perl modules under `./.developer-dashboard/local` and appends matching requirements to `./.developer-dashboard/cpanfile`, with automatic `DBI` handling for `DBD::*` requests, while keeping the...
## Release To PAUSE
integration/blank-env/run-integration.pl view on Meta::CPAN
}
return {
command => $command,
exit_code => $exit_code,
stdout => defined $stdout ? $stdout : '',
stderr => defined $stderr ? $stderr : '',
};
}
# _capture_stream_prefix($label, $command, %opts)
# Runs one streaming shell command and records when expected stdout chunks first appear.
# Input: human label, shell command string, expected_chunks array ref, and optional timeout seconds.
# Output: hash reference with stdout, stderr, and matched event timing data.
sub _capture_stream_prefix {
my ( $label, $command, %opts ) = @_;
my $expected = $opts{expected_chunks} || [];
my $timeout = $opts{timeout} || 5;
print "==> $label\n";
print " $command\n";
my $stderr_fh = gensym();
my $pid = open3( undef, my $stdout_fh, $stderr_fh, 'sh', '-lc', $command );
lib/Developer/Dashboard.pm view on Meta::CPAN
use C<dashboard docker list>. Add C<--disabled> to show only disabled
services or C<--enabled> to show only enabled services.
During compose execution the dashboard exports C<DDDC> as the effective
config-root docker directory for the current runtime, so compose YAML can keep using
C<${DDDC}> paths inside the YAML itself. Wrapper flags such as
C<--service>, C<--addon>, C<--mode>, C<--project>, and C<--dry-run> are
consumed first, and all remaining docker compose flags such as C<-d> and
C<--build> pass straight through to the real C<docker compose> command.
When C<--dry-run> is omitted, the dashboard hands off with C<exec> so the
terminal sees the normal streaming output from C<docker compose> itself
instead of a dashboard JSON wrapper.
=head2 Prompt Integration
Render prompt text directly:
dashboard ps1 --jobs 2
C<dashboard ps1> now follows the original F<~/bin/ps1> shape more closely: a
C<(YYYY-MM-DD HH:MM:SS)> timestamp prefix, dashboard status and ticket info, a
lib/Developer/Dashboard/PageRuntime.pm view on Meta::CPAN
# _noop_writer(@parts)
# Accepts streamed output chunks when the caller does not need them.
# Input: zero or more ignored chunk parts.
# Output: empty string.
sub _noop_writer { return '' }
# _drain_saved_ajax_ready_handle(%args)
# Reads one ready saved-Ajax process pipe handle and forwards the chunk or error to the right writer.
# Input: ready fh, active select set, stdout fh, saved file path, and writer callbacks.
# Output: true value when streaming should continue, otherwise false when the client disconnected.
sub _drain_saved_ajax_ready_handle {
my ( $self, %args ) = @_;
my $fh = $args{fh} || die 'Missing ready handle';
my $path = $args{path} || '';
my $select = $args{select} || die 'Missing select set';
my $stdout = $args{stdout} || die 'Missing stdout handle';
my $stdout_writer = $args{stdout_writer} || \&_noop_writer;
my $stderr_writer = $args{stderr_writer} || \&_noop_writer;
my $chunk = '';
my $bytes = $self->_stream_sysread( $fh, \$chunk );
lib/Developer/Dashboard/PageRuntime.pm view on Meta::CPAN
my $stdout_fileno = fileno($stdout);
if ( defined $ready_fileno && defined $stdout_fileno && $ready_fileno == $stdout_fileno ) {
my $continued = $stdout_writer->($chunk);
return defined $continued ? $continued : 1;
}
my $continued = $stderr_writer->($chunk);
return defined $continued ? $continued : 1;
}
# _close_saved_ajax_streams($select, @handles)
# Closes the saved-Ajax select set and any remaining pipe handles after streaming stops.
# Input: IO::Select object plus zero or more pipe handles.
# Output: true value.
sub _close_saved_ajax_streams {
my ( $self, $select, @handles ) = @_;
if ( $select && eval { $select->can('handles') } ) {
for my $fh ( $select->handles ) {
next if !defined fileno($fh);
$select->remove($fh);
close $fh;
}
lib/Developer/Dashboard/PageRuntime/StreamHandle.pm view on Meta::CPAN
=head1 METHODS
=head2 TIEHANDLE, PRINT, PRINTF, CLOSE
Implement the tied-handle contract used by streamed bookmark Ajax execution.
=for comment FULL-POD-DOC START
=head1 PURPOSE
This module is the small stream object used by page runtime and web streaming code. It presents one consistent write interface for incremental output so bookmark runtime code and server-side streaming can push chunks without depending on a specific P...
=head1 WHY IT EXISTS
It exists because streaming output is easier to test when the stream sink is a small object instead of a raw callback buried in transport code. That separation also keeps disconnect handling and chunk capture explicit.
=head1 WHEN TO USE
Use this file when changing streaming write semantics, buffering behavior, or tests around incremental page output and broken-pipe handling.
=head1 HOW TO USE
Construct it with the callback or sink expected by the caller, then pass it into the part of the runtime that wants to emit streaming content. Keep transport-neutral streaming behavior here rather than tying it to one web-server code path.
=head1 WHAT USES IT
It is used by page-runtime streaming helpers, by web response code that needs incremental output, and by coverage tests around streamed bookmark and Ajax behavior.
=head1 EXAMPLES
Example 1:
perl -Ilib -MDeveloper::Dashboard::PageRuntime::StreamHandle -e 1
Do a direct compile-and-load check against the module from a source checkout.
Example 2:
lib/Developer/Dashboard/SkillDispatcher.pm view on Meta::CPAN
my $hook_stderr = join '', map { defined $_->{stderr} ? $_->{stderr} : '' } values %{ $hook_result->{hooks} || {} };
return {
stdout => $hook_stdout . $stdout,
stderr => $hook_stderr . $stderr,
exit_code => $exit,
hooks => $hook_result->{hooks} || {},
};
}
# exec_command($skill_name, $command, @args)
# Executes one skill command by streaming hooks first and then replacing the
# current helper process with the resolved skill command so interactive stdin,
# stdout, and stderr behave exactly like a direct invocation.
# Input: skill repo name, command name, and command arguments.
# Output: never returns on success; otherwise returns an error hash.
sub exec_command {
my ( $self, $skill_name, $command, @args ) = @_;
return { error => 'Missing skill name' } if !$skill_name;
return { error => 'Missing command name' } if !$command;
my $skill_path = $self->{manager}->get_skill_path( $skill_name, include_disabled => 1 );
lib/Developer/Dashboard/SkillDispatcher.pm view on Meta::CPAN
);
return { error => $suggest->unknown_skill_command_message( $skill_name, $command ) } if !$skill_path;
return { error => $suggest->unknown_skill_command_message( $skill_name, $command ) } if !$self->{manager}->is_enabled($skill_name);
my $command_spec = $self->_command_spec( $skill_name, $command );
my $cmd_path = $command_spec ? $command_spec->{cmd_path} : undef;
my $command_skill_path = $command_spec ? $command_spec->{skill_path} : undef;
return { error => $suggest->unknown_skill_command_message( $skill_name, $command ) } if !$cmd_path;
my @skill_layers = $command_spec ? @{ $command_spec->{skill_layers} || [] } : $self->_skill_layers($skill_name);
my $hook_result = $self->_execute_hooks_streaming( $skill_name, $command_spec ? $command_spec->{command_name} : $command, \@skill_layers, @args );
return $hook_result if $hook_result->{error};
my %env = $self->_skill_env(
skill_name => $skill_name,
skill_path => $command_skill_path || $skill_path,
skill_layers => \@skill_layers,
command => $command_spec ? $command_spec->{command_name} : $command,
result_state => $hook_result->{result_state} || {},
);
my @command = command_argv_for_path($cmd_path);
lib/Developer/Dashboard/SkillDispatcher.pm view on Meta::CPAN
closedir($dh);
}
my %payload = (
hooks => \%results,
result_state => \%results,
);
$payload{last_result} = $last_result if %{$last_result};
return \%payload;
}
# _execute_hooks_streaming($skill_name, $command, $skill_layers, @args)
# Executes skill hook files while preserving live stdio so interactive hooks
# and later main commands can still read from the caller's stdin and print
# prompts without buffering surprises.
# Input: skill repo name, resolved command name, array reference of skill layer
# paths, and command arguments.
# Output: hash reference containing hook captures, result_state, and
# last_result.
sub _execute_hooks_streaming {
my ( $self, $skill_name, $command, $skill_layers, @args ) = @_;
return { hooks => {}, result_state => {} } if !$skill_name || !$command;
my @skill_layers = @{ $self->_arrayref_or_empty($skill_layers) };
return { hooks => {}, result_state => {} } if !@skill_layers;
my %results;
my $last_result = {};
for my $layer_path (@skill_layers) {
my $hooks_dir = File::Spec->catdir( $layer_path, 'cli', "$command.d" );
next if !-d $hooks_dir;
lib/Developer/Dashboard/SkillDispatcher.pm view on Meta::CPAN
next unless is_runnable_file($hook_path);
my %env = $self->_skill_env(
skill_name => $skill_name,
skill_path => $layer_path,
skill_layers => \@skill_layers,
command => $command,
result_state => \%results,
);
my @hook_command = command_argv_for_path($hook_path);
my $run = $self->_run_child_command_streaming(
command => \@hook_command,
args => \@args,
env => \%env,
skill_layers => \@skill_layers,
result_state => \%results,
last_result => $last_result,
stdin_mode => 'null',
);
my $result_key = $entry;
if ( exists $results{$entry} ) {
lib/Developer/Dashboard/SkillDispatcher.pm view on Meta::CPAN
}
my %payload = (
hooks => \%results,
result_state => \%results,
);
$payload{last_result} = $last_result if %{$last_result};
return \%payload;
}
# _run_child_command_streaming(%args)
# Launches one child command with inherited stdin, streams stdout and stderr
# live, and still captures both streams for RESULT-aware callers.
# Input: hash containing command array ref, args array ref, env hash ref,
# skill_layers array ref, result_state hash ref, optional last_result hash
# ref, and optional stdin_mode string.
# Output: hash reference containing stdout, stderr, and exit_code.
sub _run_child_command_streaming {
my ( $self, %args ) = @_;
my @command = @{ $self->_arrayref_or_empty( $args{command} ) };
my @argv = @{ $self->_arrayref_or_empty( $args{args} ) };
my %env = %{ $self->_hashref_or_empty( $args{env} ) };
my @skill_layers = @{ $self->_arrayref_or_empty( $args{skill_layers} ) };
my $result_state = $self->_hashref_or_empty( $args{result_state} );
my $last_result = $args{last_result};
my $stdin_mode = $self->_defined_or_default( $args{stdin_mode}, 'inherit' );
my $stdin_spec = '<&STDIN';
my $stdin_fh;
if ( $stdin_mode eq 'null' ) {
open $stdin_fh, '<', File::Spec->devnull() or die "Unable to open " . File::Spec->devnull() . " for streaming skill hook stdin: $!";
$stdin_spec = '<&' . fileno($stdin_fh);
}
my $stderr = gensym();
my $stdout;
my ( $stdout_text, $stderr_text ) = ( '', '' );
my $pid;
{
local %ENV = ( %ENV, %env );
Developer::Dashboard::Runtime::Result::set_current($result_state);
if ( ref($last_result) eq 'HASH' && %{$last_result} ) {
lib/Developer/Dashboard/UpdateManager.pm view on Meta::CPAN
Construct and execute dashboard updates.
=for comment FULL-POD-DOC START
=head1 PURPOSE
This module runs the ordered update hook chain for C<dashboard update>. It discovers executable update scripts, runs them in sorted order, streams their stdout and stderr, updates the structured C<RESULT> state between hooks, and coordinates collecto...
=head1 WHY IT EXISTS
It exists because update hooks are a first-class runtime workflow, not a one-off shell loop. The dashboard needs one module that owns ordering, streaming, structured hook results, and collector lifecycle around updates.
=head1 WHEN TO USE
Use this file when changing update hook discovery, update streaming behavior, RESULT propagation between update hooks, or the way updates stop and restart collectors.
=head1 HOW TO USE
Construct it with the file registry, path registry, and collector runner, then call its run method from the update command. Keep update hook execution policy in this module rather than in the command wrapper.
=head1 WHAT USES IT
It is used by the C<dashboard update> flow, by runtime bootstrap/update smoke tests, and by coverage that verifies update hook ordering and collector restart semantics.
=head1 EXAMPLES
lib/Developer/Dashboard/Web/DancerApp.pm view on Meta::CPAN
my ($index) = @_;
my @parts = splat;
@parts = @{ $parts[0] } if @parts == 1 && ref( $parts[0] ) eq 'ARRAY';
return undef if !@parts;
return $parts[$index];
}
# _response_from_result($result)
# Applies one backend response onto the active Dancer2 response object.
# Input: backend response array reference.
# Output: plain body or delayed streaming response suitable for Dancer2.
sub _response_from_result {
my ($result) = @_;
my ( $code, $type, $body, $headers ) = @{$result};
my $backend = _current_backend();
my %merged_headers = (
%{ $backend->{default_headers} || {} },
%{ $headers || {} },
);
if ( ref($body) eq 'HASH' && ref( $body->{stream} ) eq 'CODE' ) {
t/03-web-app.t view on Meta::CPAN
use Developer::Dashboard::DataHelper qw( j );
print j { ok => 1 };
};
PAGE
$store->save_page($fetch_stream_page);
my ($fetch_stream_code, undef, $fetch_stream_body) = @{ $app->handle(path => '/app/fetch-stream-helpers', query => '', remote_addr => '127.0.0.1', headers => { host => '127.0.0.1' }) };
is($fetch_stream_code, 200, 'legacy bookmark with fetch_value and stream_value helpers renders');
like($fetch_stream_body, qr/function fetch_value\(url, target, options, formatter\)/, 'legacy bookmark bootstrap exposes fetch_value helper');
like($fetch_stream_body, qr/function stream_value\(url, target, options, formatter\)/, 'legacy bookmark bootstrap exposes stream_value helper');
like($fetch_stream_body, qr/function stream_data\(url, target, options, formatter\)/, 'legacy bookmark bootstrap exposes stream_data helper');
like($fetch_stream_body, qr/new XMLHttpRequest\(\)/, 'legacy bookmark streaming helper uses XMLHttpRequest for progressive browser updates');
like($fetch_stream_body, qr/xhr\.onprogress = function \(\)/, 'legacy bookmark streaming helper updates targets from incremental ajax progress events');
my $foo_bind_pos = index($fetch_stream_body, q{set_chain_value(endpoints,'foo','/ajax/foo?type=text'});
my $bar_bind_pos = index($fetch_stream_body, q{set_chain_value(endpoints,'bar','/ajax/bar?type=text&singleton=BAR'});
my $mike_bind_pos = index($fetch_stream_body, q{set_chain_value(endpoints,'mike','/ajax/mike?type=json'});
my $endpoints_decl_pos = index($fetch_stream_body, q{var endpoints = {};});
my $fetch_call_pos = index($fetch_stream_body, q{fetch_value(endpoints.foo, '#foo');});
ok($foo_bind_pos > -1 && $bar_bind_pos > -1 && $mike_bind_pos > -1, 'legacy bookmark render includes all saved Ajax endpoint bindings for fetch_value and stream_value');
ok($endpoints_decl_pos > -1, 'legacy bookmark render keeps the caller endpoint variable declaration');
ok($foo_bind_pos > $endpoints_decl_pos && $bar_bind_pos > $endpoints_decl_pos && $mike_bind_pos > $endpoints_decl_pos, 'saved Ajax endpoint bindings render after the caller declares the endpoint root object');
ok($fetch_call_pos > -1, 'legacy bookmark render keeps the inline fetch helper call');
like($fetch_stream_body, qr/dashboard_ajax_singleton_cleanup\('BAR'\)/, 'legacy bookmark render keeps singleton cleanup bindings for stream_value pages');
t/03-web-app.t view on Meta::CPAN
my $manual_ajax_token = uri_escape( encode_payload(q{print j { blocked => 1 };}) );
my ($blocked_ajax_code, $blocked_ajax_type, $blocked_ajax_body) = @{ $app->handle(path => '/ajax', query => "token=$manual_ajax_token&type=json", remote_addr => '127.0.0.1', headers => { host => '127.0.0.1' }) };
is($blocked_ajax_code, 403, 'legacy ajax token route is denied when transient token URLs are disabled');
like($blocked_ajax_type, qr/text\/plain/, 'legacy ajax token denial returns plain text');
like($blocked_ajax_body, qr/Transient token URLs are disabled/, 'legacy ajax token denial explains the policy');
}
{
local $ENV{DEVELOPER_DASHBOARD_ALLOW_TRANSIENT_URLS} = 1;
my $manual_ajax_token = uri_escape( encode_payload(q{die "token ajax died\n";}) );
my ($manual_ajax_error_code, $manual_ajax_error_type, $manual_ajax_error_body) = @{ $app->handle(path => '/ajax', query => "token=$manual_ajax_token&type=text", remote_addr => '127.0.0.1', headers => { host => '127.0.0.1' }) };
is($manual_ajax_error_code, 200, 'legacy ajax token runtime errors still return the streaming response shape');
like($manual_ajax_error_type, qr/text\/plain/, 'legacy ajax token runtime errors keep the requested content type');
like(drain_stream_body($manual_ajax_error_body), qr/token ajax died/, 'legacy ajax token runtime errors stream the runtime error text');
}
my $script_breakout_source = join "\n",
'BOOKMARK: script-breakout',
':--------------------------------------------------------------------------------:',
q{HTML: <script src="/js/jquery.js"></script>},
q{<script>console.log("hello")</script>},
':--------------------------------------------------------------------------------:',
t/05-cli-smoke.t view on Meta::CPAN
use strict;
use warnings;
print $ENV{RESULT} // '';
PL
close $custom_run_fh;
chmod 0755, $custom_run or die "Unable to chmod $custom_run: $!";
my ( $custom_stdout, $custom_stderr, $custom_exit ) = capture {
system 'sh', '-c', "$perl -I'$lib' '$dashboard' inspect-result";
return $? >> 8;
};
is( $custom_exit, 0, 'directory-backed custom command succeeds after hook streaming' );
like( $custom_stdout, qr/^custom-hook\n/s, 'directory-backed custom command streams hook stdout before the final RESULT json' );
like( $custom_stderr, qr/custom-hook-err\n/, 'directory-backed custom command streams hook stderr live' );
my ($custom_json) = $custom_stdout =~ /(\{[\s\S]*\})\s*\z/;
ok( defined $custom_json, 'directory-backed custom command leaves trailing RESULT json after streamed hook output' );
my $custom_result_data = json_decode($custom_json);
is( $custom_result_data->{'00-pre.pl'}{stdout}, "custom-hook\n", 'directory-backed custom commands receive RESULT JSON from their hook files' );
like( $custom_result_data->{'00-pre.pl'}{stderr}, qr/custom-hook-err/, 'directory-backed custom command RESULT keeps captured hook stderr' );
my $report_dir_root = File::Spec->catdir( $ENV{HOME}, '.developer-dashboard', 'cli', 'report-result' );
make_path($report_dir_root);
t/08-web-update-coverage.t view on Meta::CPAN
}
{
my ( $ajax_bad_file_code, $ajax_bad_file_type, $ajax_bad_file_body ) = @{ $app->handle( path => '/ajax', query => 'file=..%2Fbad&type=json', remote_addr => '127.0.0.1', headers => { host => '127.0.0.1' } ) };
is( $ajax_bad_file_code, 400, 'legacy ajax route rejects invalid saved bookmark ajax file names cleanly' );
like( $ajax_bad_file_type, qr/text\/plain/, 'legacy ajax invalid saved-file route returns plain text' );
like( $ajax_bad_file_body, qr/invalid parent traversal/, 'legacy ajax invalid saved-file route returns the validation error text' );
}
{
my $streaming_page = Developer::Dashboard::PageDocument->from_instruction(<<'PAGE');
BOOKMARK: ajax-stream
:--------------------------------------------------------------------------------:
HTML: <script>var configs = {};</script>
:--------------------------------------------------------------------------------:
CODE1: Ajax jvar => 'configs.demo.endpoint', type => 'text', file => 'stream.txt', code => q{
print "first\n";
print "second\n";
};
PAGE
$store->save_page($streaming_page);
my ( undef, undef, undef ) = @{ $app->handle( path => '/app/ajax-stream', query => '', remote_addr => '127.0.0.1', headers => { host => '127.0.0.1' } ) };
my ( $ajax_stream_code, $ajax_stream_type, $ajax_stream_body ) = @{ $app->handle( path => '/ajax/stream.txt', query => 'type=text', remote_addr => '127.0.0.1', headers => { host => '127.0.0.1' } ) };
is( $ajax_stream_code, 200, 'legacy ajax saved-file route responds successfully for streaming output' );
like( $ajax_stream_type, qr/text\/plain/, 'legacy ajax saved-file route keeps the requested content type for streaming output' );
is( drain_stream_body($ajax_stream_body), "first\nsecond\n", 'legacy ajax saved-file route streams raw printed output without page buffering' );
}
{
my $process_page = Developer::Dashboard::PageDocument->from_instruction(<<'PAGE');
BOOKMARK: ajax-process
:--------------------------------------------------------------------------------:
HTML: <script>var configs = {};</script>
:--------------------------------------------------------------------------------:
CODE1: Ajax jvar => 'configs.demo.endpoint', type => 'text', file => 'process-endpoint.json', code => q{
t/08-web-update-coverage.t view on Meta::CPAN
print "$0\n";
};
PAGE
$store->save_page($singleton_page);
my ( undef, undef, $singleton_page_body ) = @{ $app->handle( path => '/app/ajax-singleton', query => '', remote_addr => '127.0.0.1', headers => { host => '127.0.0.1' } ) };
like( $singleton_page_body, qr{/ajax/singleton-endpoint\.txt\?type=text&singleton=FOOBAR}, 'saved bookmark Ajax page emits the singleton query parameter in the generated ajax url' );
like( $singleton_page_body, qr/dashboard_ajax_singleton_cleanup\('FOOBAR'\)/, 'saved bookmark Ajax page registers browser lifecycle cleanup for singleton-managed workers' );
my ( $ajax_singleton_code, undef, $ajax_singleton_body ) = @{ $app->handle( path => '/ajax/singleton-endpoint.txt', query => 'type=text&singleton=FOOBAR', remote_addr => '127.0.0.1', headers => { host => '127.0.0.1' } ) };
my $ajax_singleton_output = drain_stream_body($ajax_singleton_body);
is( $ajax_singleton_code, 200, 'legacy ajax saved-file route responds successfully for singleton-managed requests' );
like( $ajax_singleton_output, qr/^dashboard ajax: FOOBAR$/m, 'legacy ajax saved-file route renames singleton-managed Perl workers before streaming output' );
}
{
my @patterns;
{
no warnings 'redefine';
local *Developer::Dashboard::RuntimeManager::_pkill_perl = sub {
my ( $self, $pattern ) = @_;
push @patterns, $pattern;
return 1;
t/08-web-update-coverage.t view on Meta::CPAN
{
my $res;
test_psgi $header_server->psgi_app, sub {
my ($cb) = @_;
$res = $cb->( POST 'http://127.0.0.1/login', [ username => 'helper', password => 'helper-pass-123' ] );
};
is( $res->header('Location'), '/login', 'server forwards custom Location headers from the app' );
is( $res->header('Set-Cookie'), 'dashboard_session=abc', 'server forwards custom Set-Cookie headers from the app' );
}
my $streaming_app = bless {}, 'Local::StreamingApp';
{
no warnings 'once';
*Local::StreamingApp::handle = sub {
return [
200,
'text/plain; charset=utf-8',
{
stream => sub {
my ($writer) = @_;
$writer->("alpha\n");
$writer->("beta\n");
},
},
{ 'X-Test' => 'streaming' },
];
};
}
my $streaming_server = Developer::Dashboard::Web::Server->new( app => $streaming_app );
{
my $res;
test_psgi $streaming_server->psgi_app, sub {
my ($cb) = @_;
$res = $cb->( GET 'http://127.0.0.1/ajax' );
};
is( $res->code, 200, 'streaming response path returns success' );
like( $res->header('Content-Type'), qr/text\/plain/, 'streaming response keeps the content type header' );
is( $res->header('X-Test'), 'streaming', 'streaming response keeps custom headers' );
is( $res->content, "alpha\nbeta\n", 'streaming response writes streamed body chunks into the final response body' );
}
my $failing_stream_app = bless {}, 'Local::FailingStreamApp';
{
no warnings 'once';
*Local::FailingStreamApp::handle = sub {
return [
200,
'text/plain; charset=utf-8',
{
t/08-web-update-coverage.t view on Meta::CPAN
];
};
}
my $failing_stream_server = Developer::Dashboard::Web::Server->new( app => $failing_stream_app );
{
my $res;
test_psgi $failing_stream_server->psgi_app, sub {
my ($cb) = @_;
$res = $cb->( GET 'http://127.0.0.1/ajax' );
};
is( $res->code, 200, 'streaming error responses keep the original success status' );
like( $res->content, qr/alpha/, 'streaming error responses keep chunks written before the failure' );
like( $res->content, qr/stream exploded/, 'streaming error responses append the streaming exception text' );
}
{
no warnings 'redefine';
my @chunks;
local *Developer::Dashboard::Web::DancerApp::delayed = sub (&) { $_[0]->(); return 'delayed-ok' };
local $Dancer2::Core::Route::RESPONDER = sub {
my ($response) = @_;
is( $response->[0], 200, 'disconnect coverage responder receives the original status code' );
like( join( "\n", @{ $response->[1] || [] } ), qr/Content-Type\ntext\/plain/, 'disconnect coverage responder receives the content type header' );
t/08-web-update-coverage.t view on Meta::CPAN
SCRIPT_NAME => '',
SERVER_NAME => '127.0.0.1',
SERVER_PORT => 7890,
'psgi.version' => [ 1, 1 ],
'psgi.url_scheme' => 'http',
'psgi.input' => do { open my $fh, '<', \q{} or die $!; $fh },
'psgi.errors' => *STDERR,
'psgi.multithread' => 0,
'psgi.multiprocess' => 0,
'psgi.run_once' => 0,
'psgi.streaming' => 1,
'psgi.nonblocking' => 0,
}
)
);
is( $res->code, 200, 'server treats missing URI queries as empty strings' );
}
{
no warnings 'redefine';
local *IO::Socket::INET::new = sub { return };
t/15-release-metadata.t view on Meta::CPAN
like( $doc, qr/\bticket\b.*~\/\.developer-dashboard\/cli|~\/\.developer-dashboard\/cli.*\bticket\b/s, 'docs describe private ticket helper staging' );
like( $doc, qr/dashboard jq/, 'docs describe the renamed jq subcommand' );
like( $doc, qr/dashboard yq/, 'docs describe the renamed yq subcommand' );
like( $doc, qr/dashboard tomq/, 'docs describe the renamed tomq subcommand' );
like( $doc, qr/dashboard propq/, 'docs describe the renamed propq subcommand' );
like( $doc, qr/dashboard of \. jq|jq\.js.*jquery\.js|jquery\.js.*jq\.js/s, 'docs describe the scoped open-file ranking behaviour' );
like( $doc, qr/Ok\\\.js\$|ok\.json|case-insensitive regex/i, 'docs describe regex-based scoped open-file matching explicitly' );
like( $doc, qr/javax\.jws\.WebService|Maven source jar|~\/\.developer-dashboard\/cache\/open-file/i, 'docs describe Java source lookup through archives and cached Maven downloads' );
like( $doc, qr/vim -p|C<vim -p>/, 'docs describe vim tab mode for blank-enter open-all' );
like( $doc, qr/stream_data\(url, target, options, formatter\)|C<stream_data\(url, target, options, formatter\)>/, 'docs describe the bookmark stream_data helper' );
like( $doc, qr/XMLHttpRequest/, 'docs describe incremental browser streaming through XMLHttpRequest' );
like( $doc, qr/Postman-style|Postman collection/, 'docs describe the Postman-style api-dashboard workspace' );
like( $doc, qr/import and export(?: of)? Postman collection v2\.1 JSON|import and export(?: of)? Postman collection v2\.1 JSON/i, 'docs describe Postman collection import/export support' );
like( $doc, qr/config\/api-dashboard/, 'docs describe the runtime config/api-dashboard collection storage path' );
like( $doc, qr/API_DASHBOARD_IMPORT_FIXTURE/, 'docs describe the generic api-dashboard import-fixture browser repro' );
like( $doc, qr/t\/25-api-dashboard-large-import-playwright\.t/, 'docs describe the oversized api-dashboard browser import regression' );
like( $doc, qr/Collections and Workspace.*top-level tabs|top-level tabs.*Collections and Workspace/s, 'docs describe the tabbed api-dashboard shell layout' );
like( $doc, qr/config\/sql-dashboard.*0700|0700.*config\/sql-dashboard/s, 'docs describe the owner-only sql-dashboard profile directory' );
like( $doc, qr/profile JSON file owner-only at `0600`|profile JSON file owner-only at C<0600>|saved profile files at `0600`|saved profile files at C<0600>/, 'docs describe owner-only sql-dashboard profile files' );
like( $doc, qr/current SQL .*browser URL instead of a saved SQL file|current SQL .*browser URL.*saved SQL file/s, 'docs describe current SQL as URL state instead of a saved SQL file' );
like( $doc, qr/stored collections as click-through tabs|collection tab strip|collection-to-collection tab strip/s, 'docs describe the tabbed api-dashboard collection browser' );
t/21-refactor-coverage.t view on Meta::CPAN
my $layered_dispatcher = Developer::Dashboard::SkillDispatcher->new( paths => $layered_paths );
my $layered_hooks = $layered_dispatcher->execute_hooks( 'shared-layer-skill', 'run-test' );
ok(
exists $layered_hooks->{hooks}{'00-pre.pl'},
'execute_hooks keeps the first hook basename for the first matching layered hook',
);
ok(
exists $layered_hooks->{hooks}{'run-test.d/00-pre.pl'},
'execute_hooks namespaces duplicate layered hook basenames by hook directory leaf',
);
my $layered_stream_hooks = $layered_dispatcher->_execute_hooks_streaming(
'shared-layer-skill',
'run-test',
[ $layered_manager->get_skill_path('shared-layer-skill'), File::Spec->catdir( $ENV{HOME}, 'skills-home', '.developer-dashboard', 'skills', 'shared-layer-skill' ) ],
);
ok(
exists $layered_stream_hooks->{hooks}{'run-test.d/00-pre.pl'},
'_execute_hooks_streaming namespaces duplicate layered hook basenames by hook directory leaf',
);
is_deeply(
$layered_dispatcher->get_skill_config('shared-layer-skill'),
{
skill_name => 'shared-layer-skill',
collectors => [
{ name => 'alpha', interval => 20 },
{ name => 'beta', interval => 30 },
],
providers => [
t/21-refactor-coverage.t view on Meta::CPAN
like( $missing_skill->{error}, qr/\n\nDid you mean:\n/, 'missing-skill dispatch guidance includes suggestion heading' );
}
{
my $missing_exec = $dispatcher->exec_command( 'missing-skill', 'run-test' );
like( $missing_exec->{error}, qr/\ASkill 'missing-skill' not found\./, 'exec_command rejects missing skills' );
like( $missing_exec->{error}, qr/\n\nDid you mean:\n/, 'missing-skill exec guidance includes suggestion heading' );
}
is_deeply( $dispatcher->execute_hooks( '', 'run-test' ), { hooks => {}, result_state => {} }, 'execute_hooks returns an empty result for missing skill names' );
is_deeply( $dispatcher->execute_hooks( 'dep-skill', '' ), { hooks => {}, result_state => {} }, 'execute_hooks returns an empty result for missing command names' );
is_deeply( $dispatcher->execute_hooks( 'missing-skill', 'run-test' ), { hooks => {}, result_state => {} }, 'execute_hooks returns an empty result for missing skills' );
is_deeply( $dispatcher->_execute_hooks_streaming( '', 'run-test', [] ), { hooks => {}, result_state => {} }, '_execute_hooks_streaming returns an empty payload for missing skill names' );
is_deeply( $dispatcher->_execute_hooks_streaming( 'dep-skill', '', [] ), { hooks => {}, result_state => {} }, '_execute_hooks_streaming returns an empty payload for missing command names' );
is_deeply( $dispatcher->_execute_hooks_streaming( 'dep-skill', 'run-test', [] ), { hooks => {}, result_state => {} }, '_execute_hooks_streaming returns an empty payload when no skill layers participate' );
ok( !$manager->disable('dep-skill')->{error}, 'disable succeeds for an installed skill' );
ok( !$manager->is_enabled('dep-skill'), 'is_enabled reports false once a skill is disabled' );
my @enabled_skill_roots = $skill_paths->installed_skill_roots;
my @all_skill_roots = $skill_paths->installed_skill_roots( include_disabled => 1 );
ok( !grep( { $_ eq $dep_skill_root } @enabled_skill_roots ), 'installed_skill_roots excludes disabled skills by default' );
ok( grep( { $_ eq $dep_skill_root } @all_skill_roots ), 'installed_skill_roots can still enumerate disabled skills when requested' );
is( $manager->get_skill_path('dep-skill'), undef, 'get_skill_path hides disabled skills from normal runtime lookup' );
ok( $manager->get_skill_path( 'dep-skill', include_disabled => 1 ), 'get_skill_path can still resolve disabled skills when explicitly requested' );
is_deeply(
$dispatcher->dispatch( 'dep-skill', 'run-test' ),
t/21-refactor-coverage.t view on Meta::CPAN
local *Developer::Dashboard::SkillDispatcher::execute_hooks = sub {
return { error => 'hook failure' };
};
is_deeply(
$dispatcher->dispatch( 'dep-skill', 'run-test' ),
{ error => 'hook failure' },
'dispatcher returns hook execution errors before launching the main skill command',
);
}
{
my $streaming_dir = tempdir( CLEANUP => 1 );
my $streaming_script = File::Spec->catfile( $streaming_dir, 'stream-child.pl' );
_write_file(
$streaming_script,
<<'PERL',
#!/usr/bin/env perl
use strict;
use warnings;
$| = 1;
print "stream-out:$ENV{SKILL_COMMAND}\n";
print STDERR "stream-err\n";
exit 7;
PERL
0755,
);
my ( $stdout, $stderr, $result ) = capture {
$dispatcher->_run_child_command_streaming(
command => [ $^X, $streaming_script ],
args => [],
env => { SKILL_COMMAND => 'run-test' },
skill_layers => [$dep_skill_root],
result_state => {},
last_result => {},
stdin_mode => 'null',
);
};
is( $stdout, "stream-out:run-test\n", '_run_child_command_streaming mirrors child stdout while using null stdin for hooks' );
is( $stderr, "stream-err\n", '_run_child_command_streaming mirrors child stderr while using null stdin for hooks' );
is( $result->{stdout}, "stream-out:run-test\n", '_run_child_command_streaming captures child stdout for RESULT handoff' );
is( $result->{stderr}, "stream-err\n", '_run_child_command_streaming captures child stderr for RESULT handoff' );
is( $result->{exit_code}, 7, '_run_child_command_streaming captures the child exit code' );
}
{
my $streaming_dir = tempdir( CLEANUP => 1 );
my $streaming_script = File::Spec->catfile( $streaming_dir, 'stream-last-result.pl' );
_write_file(
$streaming_script,
<<'PERL',
#!/usr/bin/env perl
use strict;
use warnings;
print "stream-last-result\n";
exit 0;
PERL
0755,
);
local *Developer::Dashboard::Runtime::Result::set_last_result = sub {
my ( $payload ) = @_;
$main::dd_last_result_payload = $payload;
return;
};
local $main::dd_last_result_payload;
my ( $stdout, $stderr, $result ) = capture {
$dispatcher->_run_child_command_streaming(
command => [ $^X, $streaming_script ],
args => [],
env => {},
skill_layers => [$dep_skill_root],
result_state => {},
last_result => { file => '/tmp/previous-hook', exit => 0, STDOUT => "old\n", STDERR => '' },
stdin_mode => 'null',
);
};
is( $stdout, "stream-last-result\n", '_run_child_command_streaming still mirrors stdout when a prior RESULT payload exists' );
is( $stderr, '', '_run_child_command_streaming keeps stderr empty when a prior RESULT payload exists and the child emits no stderr' );
is_deeply(
$main::dd_last_result_payload,
{ file => '/tmp/previous-hook', exit => 0, STDOUT => "old\n", STDERR => '' },
'_run_child_command_streaming reloads the previous RESULT payload before launching the child',
);
is( $result->{exit_code}, 0, '_run_child_command_streaming preserves successful exit codes while restoring the previous RESULT payload' );
}
{
my $stdin_dir = tempdir( CLEANUP => 1 );
my $stdin_script = File::Spec->catfile( $stdin_dir, 'stdin-child.pl' );
_write_file(
$stdin_script,
<<'PERL',
#!/usr/bin/env perl
use strict;
use warnings;
t/21-refactor-coverage.t view on Meta::CPAN
my $stdin_text = File::Spec->catfile( $stdin_dir, 'stdin.txt' );
_write_file( $stdin_text, "hello-from-stdin\n" );
open my $saved_stdin, '<&', \*STDIN or die "Unable to duplicate original STDIN: $!";
open my $saved_stdout, '>&', \*STDOUT or die "Unable to duplicate original STDOUT: $!";
open my $saved_stderr, '>&', \*STDERR or die "Unable to duplicate original STDERR: $!";
my $stdout_path = File::Spec->catfile( $stdin_dir, 'stdout.txt' );
my $stderr_path = File::Spec->catfile( $stdin_dir, 'stderr.txt' );
open STDIN, '<', $stdin_text or die "Unable to open stdin fixture file: $!";
open STDOUT, '>', $stdout_path or die "Unable to redirect stdout fixture file: $!";
open STDERR, '>', $stderr_path or die "Unable to redirect stderr fixture file: $!";
my $result = $dispatcher->_run_child_command_streaming(
command => [ $^X, $stdin_script ],
args => [],
env => {},
skill_layers => [$dep_skill_root],
result_state => {},
last_result => {},
stdin_mode => 'inherit',
);
open STDIN, '<&', $saved_stdin or die "Unable to restore original STDIN: $!";
open STDOUT, '>&', $saved_stdout or die "Unable to restore original STDOUT: $!";
t/21-refactor-coverage.t view on Meta::CPAN
my $stdout = do {
open my $fh, '<', $stdout_path or die "Unable to read captured stdout fixture file: $!";
local $/;
<$fh>;
};
my $stderr = do {
open my $fh, '<', $stderr_path or die "Unable to read captured stderr fixture file: $!";
local $/;
<$fh>;
};
is( $stdout, "stdin:hello-from-stdin\n", '_run_child_command_streaming preserves interactive stdin when requested' );
is( $stderr, '', '_run_child_command_streaming keeps stderr empty when the child emits no stderr' );
is( $result->{stdout}, "stdin:hello-from-stdin\n", '_run_child_command_streaming captures inherited-stdin child stdout' );
is( $result->{stderr}, '', '_run_child_command_streaming captures an empty stderr stream when nothing is emitted' );
is( $result->{exit_code}, 0, '_run_child_command_streaming captures a successful inherited-stdin exit code' );
}
{
my $hook_dir = File::Spec->catdir( $dep_skill_root, 'cli', 'streaming-hook.d' );
make_path($hook_dir);
my $hook_script = File::Spec->catfile( $hook_dir, '00-stream.pl' );
_write_file(
$hook_script,
<<'PERL',
#!/usr/bin/env perl
use strict;
use warnings;
$| = 1;
print "hook-stream-out\n";
print STDERR "hook-stream-err\n";
exit 4;
PERL
0755,
);
my ( $stdout, $stderr, $result ) = capture {
$dispatcher->_execute_hooks_streaming( 'dep-skill', 'streaming-hook', [$dep_skill_root] );
};
is( $stdout, "hook-stream-out\n", '_execute_hooks_streaming mirrors hook stdout live' );
is( $stderr, "hook-stream-err\n", '_execute_hooks_streaming mirrors hook stderr live' );
is_deeply(
$result->{hooks}{'00-stream.pl'},
{
stdout => "hook-stream-out\n",
stderr => "hook-stream-err\n",
exit_code => 4,
},
'_execute_hooks_streaming captures hook stdout, stderr, and exit code',
);
is_deeply(
$result->{last_result},
{
file => $hook_script,
exit => 4,
STDOUT => "hook-stream-out\n",
STDERR => "hook-stream-err\n",
},
'_execute_hooks_streaming records the last streaming hook result for downstream RESULT consumers',
);
}
{
no warnings 'redefine';
local %ENV = %ENV;
my %seen;
local *Developer::Dashboard::SkillDispatcher::_execute_hooks_streaming = sub {
return {
hooks => { pre => { stdout => "hook\n", stderr => '', exit_code => 0 } },
result_state => { pre => { stdout => "hook\n", stderr => '', exit_code => 0 } },
last_result => { file => '/tmp/hook', exit => 0, STDOUT => "hook\n", STDERR => '' },
};
};
local *Developer::Dashboard::SkillDispatcher::_exec_resolved_command = sub {
my ( $self, $cmd_path, $command, $args ) = @_;
$seen{cmd_path} = $cmd_path;
$seen{command} = [ @{$command} ];
t/21-refactor-coverage.t view on Meta::CPAN
is_deeply( $exec_result->{skill_layers}, [$dep_skill_root], 'exec_command loads the participating skill layers before exec' );
is( $exec_result->{runtime_layers_loaded}, 1, 'exec_command reloads runtime env layers before replacing the helper process' );
is_deeply(
$exec_result->{last},
{ file => '/tmp/hook', exit => 0, STDOUT => "hook\n", STDERR => '' },
'exec_command forwards the last hook RESULT payload into Runtime::Result',
);
}
{
no warnings 'redefine';
local *Developer::Dashboard::SkillDispatcher::_execute_hooks_streaming = sub { return { error => 'stream hook failure' } };
is_deeply(
$dispatcher->exec_command( 'dep-skill', 'run-test' ),
{ error => 'stream hook failure' },
'exec_command stops before exec when streaming hooks report an error',
);
}
{
my ( undef, undef, $exec_error ) = capture {
local *Developer::Dashboard::SkillDispatcher::_exec_replacement = sub { return 'mock exec failure'; };
$dispatcher->_exec_resolved_command( '/no/such/path', [ '/definitely/missing-skill-command' ], [] );
};
like( $exec_error->{error}, qr/\AUnable to exec \/no\/such\/path: mock exec failure/, '_exec_resolved_command reports direct exec failures clearly' );
}
{
no warnings 'redefine';
local *Developer::Dashboard::SkillDispatcher::_execute_hooks_streaming = sub {
return {
hooks => {},
result_state => {},
};
};
local *Developer::Dashboard::SkillDispatcher::_exec_resolved_command = sub {
my $last_result = Developer::Dashboard::Runtime::Result::last_result();
return {
success => 1,
last_result => $last_result,
( run in 3.205 seconds using v1.01-cache-2.11-cpan-39bf76dae61 )