Reverse engineer anything with agents, from app behavior down to native binaries.
TypeScript agent-skillsai-agentsbinary-analysisclaude-codeclicodexcordisdecompilerdeveloper-toolsdshdsh-pluginghidrahopperllmmcpmodel-context-protocolreareverse-engineeringstatic-analysistouhou
#!/usr/bin/env node
// Unchanged Joplin ASAR and its shipped welcome note/attachment. The actual
// resource context menu, bridge and shell call execute; menu automation is explicit.
import assert from "node:assert/strict";
import { createHash } from "node:crypto";
import { mkdtemp, readFile, writeFile } from "node:fs/promises";
import { dirname, join, resolve } from "node:path";
import { pathToFileURL } from "node:url";
import { parseArgs } from "node:util";
import { _electron } from "playwright-core";
const { values } = parseArgs({
options: {
"runtime-root": { type: "string" },
executable: { type: "string" },
application: { type: "string" },
"profile-root": { type: "string" },
"argv-shim-transport": { type: "boolean", default: false },
},
});
for (const key of ["runtime-root", "executable", "application", "profile-root"])
assert.ok(values[key], `Missing --${key}`);
const runtime = resolve(values["runtime-root"]);
const { PlaywrightElectronActiveProvider } = await import(
pathToFileURL(
join(runtime, "dist/browser/PlaywrightElectronActiveProvider.js"),
)
);
const { captureElectronScenario } = await import(
pathToFileURL(
join(
runtime,
"dist/application/javascript/ElectronActiveObservationService.js",
),
)
);
const profile = await mkdtemp(
join(resolve(values["profile-root"]), "joplin-shell-"),
);
let application;
let child;
let probe;
let stagedHookHashes;
const started = performance.now();
const controller = new AbortController();
const deadline = setTimeout(
() => controller.abort(new Error("Verifier deadline")),
45_000,
);
const verifyHookSources = async (stagedHook) => {
const hashes = {};
for (const name of [
"electron-active-hook.cjs",
"electron-active-hook-boundaries.cjs",
]) {
const hash = (data) => createHash("sha256").update(data).digest("hex");
const actualPath =
name === "electron-active-hook.cjs"
? stagedHook
: join(dirname(stagedHook), name);
const [actual, expected] = await Promise.all([
readFile(actualPath).then(hash),
readFile(join(runtime, "scripts", name)).then(hash),
]);
assert.equal(
actual,
expected,
`The staged ${name} must match the selected runtime source`,
);
hashes[name] = actual;
}
return hashes;
};
const launch = async (options) => {
const stagedIndex = options.args.indexOf("-r");
assert.notEqual(
stagedIndex,
-1,
"Expected the provider's staged require pair",
);
stagedHookHashes = await verifyHookSources(options.args[stagedIndex + 1]);
let launchOptions = options;
if (values["argv-shim-transport"]) {
// Explicit test adapter for #2974, not the public provider launch path.
const args = [...options.args];
const index = args.indexOf("-r");
assert.notEqual(index, -1, "Expected the provider's staged require pair");
const hook = args[index + 1];
const shim = join(profile, "launch-shim.cjs");
await writeFile(
shim,
`require(${JSON.stringify(hook)});\nconst index = process.argv.indexOf("-r");\nif (index < 0 || process.argv[index + 1] !== __filename) throw new Error("Unexpected staged argv");\nprocess.argv.splice(index, 2);\n`,
);
args[index + 1] = shim;
launchOptions = { ...options, args };
}
application = await _electron.launch(launchOptions);
child = application.process();
assert.equal(
await application.evaluate(
() => typeof globalThis.__reaElectronActiveSnapshot,
),
"function",
"The staged active hook must be installed before app actions",
);
const page = await application.firstWindow({ timeout: 15_000 });
const pageErrors = [];
page.on("pageerror", (error) => {
if (pageErrors.length < 5) pageErrors.push(String(error).slice(0, 600));
});
await page.getByPlaceholder("Search...").waitFor({ timeout: 15_000 });
await page
.getByText("1. Welcome to Joplin!", { exact: true })
.first()
.click({ timeout: 20_000 });
const viewer = page.locator("iframe.noteTextViewer");
for (
let attempt = 0;
attempt < 3 && !(await viewer.isVisible());
attempt += 1
) {
await application.evaluate(({ Menu }) => {
const item =
Menu.getApplicationMenu()?.getMenuItemById("toggleVisiblePanes");
if (!item) throw new Error("Missing Joplin editor layout menu");
item.click();
});
await viewer
.waitFor({ state: "visible", timeout: 3_000 })
.catch(() => undefined);
}
const image = page
.frameLocator("iframe.noteTextViewer")
.locator("img")
.first();
try {
await image.waitFor({ timeout: 15_000 });
} catch (cause) {
console.log(
JSON.stringify({
viewer_visible: await viewer.isVisible(),
frames: await Promise.all(
page
.frames()
.slice(0, 5)
.map(async (frame) => ({
url: frame.url(),
state: await frame.evaluate(() => ({
text: document.body?.innerText.slice(0, 500),
images: document.images.length,
})),
})),
),
}),
);
throw cause;
}
const attachment = await image.evaluate((element) => ({
src: element.getAttribute("src"),
alt: element.getAttribute("alt"),
width: element.naturalWidth,
height: element.naturalHeight,
}));
assert.ok(
attachment.width > 0 && attachment.height > 0,
"The shipped welcome attachment must render",
);
const beforeShellCount = await application.evaluate(
() =>
globalThis
.__reaElectronActiveSnapshot()
.events.filter(
(event) =>
event.kind === "shell-attempt" &&
event.event === "showItemInFolder",
).length,
);
assert.equal(
beforeShellCount,
0,
"A startup event cannot prove the requested reveal",
);
// Capture the app's actual context menu instead of opening a native popup.
await application.evaluate(({ Menu }) => {
const original = Menu.prototype.popup;
globalThis.__reaShellMenuProbe = { original, menu: null };
Menu.prototype.popup = function captureMenu() {
globalThis.__reaShellMenuProbe.menu = this;
};
});
await image.click({ button: "right" });
const revealed = await application.evaluate(async ({ Menu }) => {
const state = globalThis.__reaShellMenuProbe;
const deadline = Date.now() + 5_000;
while (state.menu === null && Date.now() < deadline) {
await new Promise((resolve) => setTimeout(resolve, 50));
}
Menu.prototype.popup = state.original;
delete globalThis.__reaShellMenuProbe;
const item = state.menu?.items.find(
(entry) => entry.label === "Reveal file in folder",
);
if (!item) throw new Error("Missing actual Joplin resource reveal menu");
await item.click();
return item.label;
});
const shell = await application.evaluate(async () => {
const read = () =>
globalThis
.__reaElectronActiveSnapshot()
.events.filter(
(event) =>
event.kind === "shell-attempt" &&
event.event === "showItemInFolder",
);
const deadline = Date.now() + 5_000;
let events = read();
while (events.length === 0 && Date.now() < deadline) {
await new Promise((resolve) => setTimeout(resolve, 50));
events = read();
}
return events;
});
assert.equal(shell.length, 1);
assert.equal(shell[0].phase, "blocked");
assert.deepEqual(shell[0].argument_shapes, ["string"]);
probe = {
before_shell_count: beforeShellCount,
note: "1. Welcome to Joplin!",
attachment,
revealed,
image_visible: await image.isVisible(),
shell,
page_errors: pageErrors,
};
return application;
};
try {
const result = await captureElectronScenario(
new PlaywrightElectronActiveProvider(process.env, launch),
{
executable_path: resolve(values.executable),
application_path: resolve(values.application),
args: [
"--no-sandbox",
"--disable-gpu",
`--user-data-dir=${profile}`,
"--profile",
profile,
],
actions: [
{
step_id: "settle-after-reveal",
kind: "wait",
window_index: 0,
duration_ms: 100,
},
],
},
{ signal: controller.signal },
);
await writeFile(join(profile, "result.json"), JSON.stringify(result));
const capture = result.ok
? result.value.normalized_result
: result.error.partialObservation?.capture;
const retainedShell = capture?.timeline.events.filter(
(event) =>
event.kind === "shell-attempt" && event.event === "showItemInFolder",
);
if (probe)
assert.deepEqual(
retainedShell,
probe.shell,
"The shared capture must retain the observed shell event",
);
console.log(
JSON.stringify({
profile,
runtime,
staged_hook_sha256: stagedHookHashes,
elapsed_ms: performance.now() - started,
launch_transport: values["argv-shim-transport"]
? "controlled-argv-shim"
: "standard-staged-argv",
probe: probe ?? null,
provider_ok: result.ok,
error: result.ok
? null
: {
tag: result.error._tag,
reason: result.error.reason,
diagnostics: result.error.diagnostics,
},
coverage: capture?.coverage,
retention: capture?.retention,
actions: capture?.actions,
deadline_triggered: controller.signal.aborted,
workflow_status:
result.ok && probe !== undefined ? "verified" : "partial-or-failed",
}),
);
assert.ok(probe, "Real Joplin resource reveal was not verified");
assert.ok(result.ok, "Provider cleanup remains unverified");
} catch (cause) {
console.log(
JSON.stringify({ verifier_failure: String(cause), probe: probe ?? null }),
);
process.exitCode = 1;
} finally {
clearTimeout(deadline);
if (application && child?.exitCode === null && child?.signalCode === null) {
let timer;
await Promise.race([
application.close().catch(() => undefined),
new Promise((resolve) => {
timer = setTimeout(resolve, 5_000);
}),
]);
clearTimeout(timer);
}
}
// The external owned scope recovers leftovers; that is not provider cleanup.
process.exit(process.exitCode ?? 0);