mirror of
https://bitbucket.org/siakitem/my-pi.git
synced 2026-08-28 08:35:57 +00:00
273 lines
13 KiB
TypeScript
273 lines
13 KiB
TypeScript
import assert from "node:assert/strict";
|
|
import { execFileSync, spawnSync } from "node:child_process";
|
|
import { mkdirSync, mkdtempSync, rmSync, symlinkSync, writeFileSync } from "node:fs";
|
|
import { tmpdir } from "node:os";
|
|
import { join } from "node:path";
|
|
import test from "node:test";
|
|
import {
|
|
buildRemoteFindCommand,
|
|
buildRemoteGrepCommand,
|
|
formatRemoteSearchOutput,
|
|
resolveRemoteSearchPath,
|
|
runRemoteFind,
|
|
runRemoteGrep,
|
|
} from "../src/remote-search.ts";
|
|
import type { RemoteExecOptions, RemoteTransport } from "../src/ssh2-transport.ts";
|
|
|
|
function grepProtocol(backend: string, rows: Array<[string, number, string]> = []): Buffer {
|
|
const fields = rows.flatMap(([path, line, content]) => [path, String(line), content]);
|
|
return Buffer.from(`__PI_SSH_SEARCH_BACKEND__:${backend}\n${fields.length > 0 ? `${fields.join("\0")}\0` : ""}`);
|
|
}
|
|
|
|
class SearchTransport implements RemoteTransport {
|
|
command = "";
|
|
cwd = "";
|
|
private readonly output: Buffer;
|
|
private readonly stderr: Buffer;
|
|
private readonly exitCode: number | null;
|
|
constructor(output: string | Buffer, exitCode: number | null = 0, stderr = "") {
|
|
this.output = Buffer.isBuffer(output) ? output : Buffer.from(output);
|
|
this.stderr = Buffer.from(stderr);
|
|
this.exitCode = exitCode;
|
|
}
|
|
connect(): Promise<void> { return Promise.resolve(); }
|
|
dispose(): Promise<void> { return Promise.resolve(); }
|
|
exec(command: string, cwd: string, options: RemoteExecOptions): Promise<{ exitCode: number | null }> {
|
|
this.command = command;
|
|
this.cwd = cwd;
|
|
options.onData(this.output);
|
|
if (this.stderr.length > 0) (options.onStderr ?? options.onData)(this.stderr);
|
|
return Promise.resolve({ exitCode: this.exitCode });
|
|
}
|
|
capture(): Promise<{ exitCode: number | null; output: Buffer }> { throw new Error("not used"); }
|
|
readFile(): Promise<Buffer> { throw new Error("not used"); }
|
|
ensureReadable(): Promise<void> { throw new Error("not used"); }
|
|
ensureReadableWritable(): Promise<void> { throw new Error("not used"); }
|
|
detectImageMimeType(): Promise<string | null> { throw new Error("not used"); }
|
|
mkdir(): Promise<void> { throw new Error("not used"); }
|
|
writeFile(): Promise<void> { throw new Error("not used"); }
|
|
}
|
|
|
|
function toolPath(name: string): string {
|
|
return execFileSync("/bin/sh", ["-c", `command -v ${name}`], { encoding: "utf8" }).trim();
|
|
}
|
|
|
|
function toolBin(root: string, names: string[]): string {
|
|
const bin = join(root, `bin-${names.join("-")}`);
|
|
mkdirSync(bin);
|
|
for (const name of names) symlinkSync(toolPath(name), join(bin, name));
|
|
return bin;
|
|
}
|
|
|
|
function execute(command: string, cwd: string, path: string) {
|
|
return spawnSync("/bin/bash", ["-c", command], { cwd, env: { ...process.env, PATH: path } });
|
|
}
|
|
|
|
test("resolves remote search roots without using local filesystem semantics", () => {
|
|
assert.equal(resolveRemoteSearchPath(undefined, "/srv/app", "/home/build"), "/srv/app");
|
|
assert.equal(resolveRemoteSearchPath("src", "/srv/app", "/home/build"), "/srv/app/src");
|
|
assert.equal(resolveRemoteSearchPath("~/logs", "/srv/app", "/home/build"), "/home/build/logs");
|
|
assert.equal(resolveRemoteSearchPath("/var/log", "/srv/app", "/home/build"), "/var/log");
|
|
assert.throws(() => resolveRemoteSearchPath("~other/project", "/srv/app", "/home/build"), /only ~ or ~\//);
|
|
});
|
|
|
|
test("builds bounded capability-adaptive commands with unified grep semantics", () => {
|
|
const find = buildRemoteFindCommand({ pattern: "it's-app", limit: 12 }, "/srv/app dir");
|
|
assert.match(find.command, /command -v fd/);
|
|
assert.match(find.command, /git-ls-files/);
|
|
assert.match(find.command, /head -n 13/);
|
|
assert.match(find.command, /'it'"'"'s-app'/);
|
|
assert.match(find.command, /'\/srv\/app dir'/);
|
|
|
|
const grep = buildRemoteGrepCommand({ pattern: "needle+", literal: false, include: "*.ts", includeHidden: true, limit: 20 }, "/srv/app");
|
|
assert.match(grep.command, /rg --null/);
|
|
assert.match(grep.command, /git .* grep .* -z .* -E/);
|
|
assert.match(grep.command, /grep -n -I -E/);
|
|
assert.match(grep.command, /PI_SSH_TAKE=21/);
|
|
assert.match(grep.command, /--hidden/);
|
|
assert.throws(() => buildRemoteGrepCommand({ pattern: "x", include: "sub\/*.ts" }, "/srv/app"), /basename glob without \//);
|
|
assert.throws(() => buildRemoteGrepCommand({ pattern: "bad\npattern" }, "/srv/app"), /newline/);
|
|
assert.throws(() => buildRemoteFindCommand({ pattern: "x", limit: 201 }, "/srv/app"), /limit/);
|
|
});
|
|
|
|
test("normalizes NUL-delimited git paths, escaped newlines, truncation, and backend", () => {
|
|
const result = formatRemoteSearchOutput(
|
|
grepProtocol("git-grep", [["src/a.ts", 2, "TODO"], ["src/line\nb.ts", 3, "TODO"], ["src/c.ts", 4, "TODO"]]),
|
|
"/srv/app",
|
|
2,
|
|
"grep",
|
|
);
|
|
assert.equal(result.backend, "git-grep");
|
|
assert.equal(result.matchCount, 2);
|
|
assert.equal(result.truncated, true);
|
|
assert.match(result.text, /\/srv\/app\/src\/a\.ts:2:TODO/);
|
|
assert.match(result.text, /src\/line\\nb\.ts:3:TODO/);
|
|
assert.doesNotMatch(result.text, /src\/c\.ts/);
|
|
});
|
|
|
|
test("executes remote find from the active workspace while searching a separate root", async () => {
|
|
const transport = new SearchTransport("__PI_SSH_SEARCH_BACKEND__:fd\n/data/search/a.ts\n");
|
|
const result = await runRemoteFind(transport, { pattern: "a", path: "/data/search", limit: 5 }, "/srv/app", "/home/build");
|
|
assert.equal(transport.cwd, "/srv/app");
|
|
assert.match(transport.command, /command -v fd/);
|
|
assert.match(transport.command, /\/data\/search/);
|
|
assert.equal(result.matchCount, 1);
|
|
assert.match(result.text, /backend: fd/);
|
|
});
|
|
|
|
test("searches a single remote file without treating the file as execution cwd", async () => {
|
|
const transport = new SearchTransport(grepProtocol("ripgrep", [["/var/log/application.log", 7, "ERROR"]]));
|
|
const result = await runRemoteGrep(transport, { pattern: "ERROR", path: "/var/log/application.log" }, "/srv/app", "/home/build");
|
|
assert.equal(transport.cwd, "/srv/app");
|
|
assert.match(transport.command, /\/var\/log\/application\.log/);
|
|
assert.equal(result.matchCount, 1);
|
|
assert.match(result.text, /application\.log:7:ERROR/);
|
|
});
|
|
|
|
test("keeps successful stderr warnings out of match rows and uses stderr for failures", async () => {
|
|
const warningTransport = new SearchTransport(grepProtocol("ripgrep"), 0, "warning: skipped socket\n");
|
|
const warningResult = await runRemoteGrep(warningTransport, { pattern: "ABSENT" }, "/srv/app", "/home/build");
|
|
assert.equal(warningResult.matchCount, 0);
|
|
assert.match(warningResult.text, /No matches found/);
|
|
assert.match(warningResult.text, /Remote warning: warning: skipped socket/);
|
|
|
|
const failed = new SearchTransport(grepProtocol("git-grep"), 128, "fatal: invalid regular expression\n");
|
|
await assert.rejects(
|
|
runRemoteGrep(failed, { pattern: "[", literal: false }, "/srv/app", "/home/build"),
|
|
(error: unknown) => {
|
|
assert.match(String(error), /remote grep failed with exit code 128: fatal: invalid regular expression/);
|
|
assert.doesNotMatch(String(error), /__PI_SSH_SEARCH_BACKEND__/);
|
|
return true;
|
|
},
|
|
);
|
|
});
|
|
|
|
test("reports actionable bounded-search timeout guidance", async () => {
|
|
const transport = new SearchTransport("");
|
|
transport.exec = () => Promise.reject(new Error("SSH command timed out after 30s"));
|
|
await assert.rejects(
|
|
runRemoteGrep(transport, { pattern: "TODO", path: "/home/build" }, "/srv/app", "/home/build"),
|
|
/remote grep timed out after 30s \(root: \/home\/build\); narrow the remote path with ssh_find/,
|
|
);
|
|
});
|
|
|
|
test("forces git-grep and fallback no-match paths and preserves real errors", () => {
|
|
const root = mkdtempSync(join(tmpdir(), "pi-ssh-search-"));
|
|
try {
|
|
mkdirSync(join(root, "src"));
|
|
writeFileSync(join(root, "src", "a.ts"), "const value = 'TODO';\n", "utf8");
|
|
execFileSync(toolPath("git"), ["init", "-q", root]);
|
|
execFileSync(toolPath("git"), ["-C", root, "add", "src/a.ts"]);
|
|
const gitPath = toolBin(root, ["git"]);
|
|
const fallbackPath = toolBin(root, ["find", "grep"]);
|
|
|
|
const grep = buildRemoteGrepCommand({ pattern: "TODO", include: "*.ts", limit: 5 }, root);
|
|
const gitProcess = execute(grep.command, root, gitPath);
|
|
assert.equal(gitProcess.status, 0, gitProcess.stderr.toString());
|
|
const gitResult = formatRemoteSearchOutput(gitProcess.stdout, root, grep.limit, "grep");
|
|
assert.equal(gitResult.backend, "git-grep");
|
|
assert.equal(gitResult.matchCount, 1);
|
|
|
|
const fallbackProcess = execute(grep.command, root, fallbackPath);
|
|
assert.equal(fallbackProcess.status, 0, fallbackProcess.stderr.toString());
|
|
const fallbackResult = formatRemoteSearchOutput(fallbackProcess.stdout, root, grep.limit, "grep");
|
|
assert.equal(fallbackResult.backend, "grep");
|
|
assert.equal(fallbackResult.matchCount, 1);
|
|
|
|
const noMatch = buildRemoteGrepCommand({ pattern: "ABSENT", include: "*.ts" }, root);
|
|
for (const path of [gitPath, fallbackPath]) {
|
|
const process = execute(noMatch.command, root, path);
|
|
assert.equal(process.status, 0, process.stderr.toString());
|
|
assert.equal(formatRemoteSearchOutput(process.stdout, root, noMatch.limit, "grep").matchCount, 0);
|
|
}
|
|
|
|
const invalidRegex = buildRemoteGrepCommand({ pattern: "[", literal: false }, root);
|
|
const invalidProcess = execute(invalidRegex.command, root, fallbackPath);
|
|
assert.notEqual(invalidProcess.status, 0);
|
|
assert.match(invalidProcess.stderr.toString(), /regular expression|bracket/i);
|
|
|
|
const missing = buildRemoteFindCommand({ pattern: "anything" }, join(root, "missing"));
|
|
const missingProcess = execute(missing.command, root, fallbackPath);
|
|
assert.notEqual(missingProcess.status, 0);
|
|
assert.match(missingProcess.stderr.toString(), /find|No such file|not found/i);
|
|
} finally {
|
|
rmSync(root, { recursive: true, force: true });
|
|
}
|
|
});
|
|
|
|
test("rg, git-grep, and fallback agree on hidden files, basename globs, and portable ERE", (context) => {
|
|
let rg: string;
|
|
try { rg = toolPath("rg"); } catch { context.skip("rg is unavailable"); return; }
|
|
const root = mkdtempSync(join(tmpdir(), "pi-ssh-search-matrix-"));
|
|
try {
|
|
mkdirSync(join(root, "sub"));
|
|
mkdirSync(join(root, ".secret"));
|
|
for (const path of ["visible.ts", "sub/nested.ts", ".hidden.ts", ".secret/deep.ts"]) {
|
|
writeFileSync(join(root, path), "needle\nneedlee\n", "utf8");
|
|
}
|
|
execFileSync(toolPath("git"), ["init", "-q", root]);
|
|
execFileSync(toolPath("git"), ["-C", root, "add", "."]);
|
|
const paths = [toolBin(root, ["rg"]), toolBin(root, ["git"]), toolBin(root, ["find", "grep"])];
|
|
assert.equal(toolPath("rg"), rg);
|
|
|
|
const runCounts = (input: Parameters<typeof buildRemoteGrepCommand>[0]) => paths.map((path) => {
|
|
const built = buildRemoteGrepCommand(input, root);
|
|
const process = execute(built.command, root, path);
|
|
assert.equal(process.status, 0, process.stderr.toString());
|
|
return formatRemoteSearchOutput(process.stdout, root, built.limit, "grep").matchCount;
|
|
});
|
|
assert.deepEqual(runCounts({ pattern: "needle", include: "*.ts" }), [4, 4, 4]);
|
|
assert.deepEqual(runCounts({ pattern: "needle", include: "*.ts", includeHidden: true }), [8, 8, 8]);
|
|
assert.deepEqual(runCounts({ pattern: "needle+", literal: false, include: "*.ts" }), [4, 4, 4]);
|
|
} finally {
|
|
rmSync(root, { recursive: true, force: true });
|
|
}
|
|
});
|
|
|
|
test("fallback NUL protocol keeps newline filenames as one bounded result", () => {
|
|
const root = mkdtempSync(join(tmpdir(), "pi-ssh-search-newline-"));
|
|
try {
|
|
const filename = "line\nbreak.ts";
|
|
writeFileSync(join(root, filename), "needle\n", "utf8");
|
|
const fallbackPath = toolBin(root, ["find", "grep"]);
|
|
const built = buildRemoteGrepCommand({ pattern: "needle", include: "*.ts" }, root);
|
|
const process = execute(built.command, root, fallbackPath);
|
|
assert.equal(process.status, 0, process.stderr.toString());
|
|
const result = formatRemoteSearchOutput(process.stdout, root, built.limit, "grep");
|
|
assert.equal(result.matchCount, 1);
|
|
assert.match(result.text, /line\\nbreak\.ts:1:needle/);
|
|
} finally {
|
|
rmSync(root, { recursive: true, force: true });
|
|
}
|
|
});
|
|
|
|
test("propagates fd and ripgrep failures while preserving ripgrep no-match", () => {
|
|
const root = mkdtempSync(join(tmpdir(), "pi-ssh-search-backends-"));
|
|
try {
|
|
const bin = join(root, "bin");
|
|
mkdirSync(bin);
|
|
const fd = join(bin, "fd");
|
|
const rg = join(bin, "rg");
|
|
writeFileSync(fd, "#!/bin/sh\necho 'fd exploded' >&2\nexit 3\n", { mode: 0o755 });
|
|
writeFileSync(rg, "#!/bin/sh\necho 'rg exploded' >&2\nexit 2\n", { mode: 0o755 });
|
|
const environment = { ...process.env, PATH: `${bin}:/usr/bin:/bin` };
|
|
|
|
const find = buildRemoteFindCommand({ pattern: "anything" }, root);
|
|
const failedFind = spawnSync("/bin/bash", ["-c", find.command], { cwd: root, env: environment });
|
|
assert.equal(failedFind.status, 3);
|
|
assert.match(failedFind.stderr.toString(), /fd exploded/);
|
|
|
|
const grep = buildRemoteGrepCommand({ pattern: "anything" }, root);
|
|
const failedGrep = spawnSync("/bin/bash", ["-c", grep.command], { cwd: root, env: environment });
|
|
assert.equal(failedGrep.status, 2);
|
|
assert.match(failedGrep.stderr.toString(), /rg exploded/);
|
|
|
|
writeFileSync(rg, "#!/bin/sh\nexit 1\n", { mode: 0o755 });
|
|
const noMatch = spawnSync("/bin/bash", ["-c", grep.command], { cwd: root, env: environment });
|
|
assert.equal(noMatch.status, 0);
|
|
assert.equal(formatRemoteSearchOutput(noMatch.stdout, root, grep.limit, "grep").matchCount, 0);
|
|
} finally {
|
|
rmSync(root, { recursive: true, force: true });
|
|
}
|
|
});
|