Compare commits

..

1 Commits

Author SHA1 Message Date
diegosouzapw
3be7e618f8 docs(ci): record what a missing App permission does to the omni-queue tick
Measured on 2026-11-17 against an installation with `actions: read`: asked
for a permission the installation does not hold, GitHub mints no token at
all (HTTP 422 for the job's whole permission set). So the tick fails at
the token step, not only the re-run of failed jobs.

The runbook said this had not been measured, described a re-run refused
with 403 as the result, and listed a revoked permission and an uninstalled
App among the causes of the full withdrawal list. Neither can happen: a
tick that gets no token stores nothing.
2026-11-17 20:03:34 -03:00
11 changed files with 70 additions and 389 deletions

View File

@@ -1 +0,0 @@
- **fix(security):** `POST /api/plugins` now installs only from the `plugin-sources` directory next to the plugin root (canonicalized with `realpath`, symlinks escaping it refused, fail closed) and requires the management credential even when login is disabled

View File

@@ -348,5 +348,7 @@
"@omniroute/opencode-plugin/tests/log-level.test.ts": "the v1 plugin no longer fetches /api/combos/auto on refresh; the retired fetcher 404 test and its import are removed with the source (21 to 19). Remaining level coverage unchanged.",
"@omniroute/opencode-plugin/tests/config-shim.test.ts": "the v1 plugin no longer fetches /api/combos/auto on refresh; the retired twin-wins case and its fixtures are removed with the static publication block (162 to 159). Remaining builder coverage unchanged.",
"tests/unit/stepfun-mono-fallback-and-sidebar-hydration-7743.test.ts": "ec27d84e (KEA-7886, F4, 2026-10-21): the legacy DashboardLayout and its synchronous localStorage collapse initializer were removed; the one dropped assert pinned that initializer. The replacement block pins the kit shell contract instead: no localStorage read in the layout files and the server passing the ci_sidebar_state cookie as sidebarDefaultOpen (3 new asserts in place of the old structure). Net count 9 -> 8 is the realignment, not a weakening. Release-green base-red #17219 (2026-10-24).",
"tests/unit/ui/rtl-logical-classes.test.tsx": "ec27d84e (KEA-7886, F4, 2026-10-21): the legacy mobile sidebar drawer (.dashboard-sidebar-mobile, start-0/-translate-x-full RTL rules) was removed with the legacy shell; its six drawer cases were replaced by the Kit shell block in the same file, which asserts the kit Sidebar Sheet anchoring by side. Net 21 -> 19 is the realignment, not a weakening. Release-green base-red #17219 (2026-10-24)."
"tests/unit/compression/ccr-non-mcp-full-prompt-loss-7746.test.ts": "fix(compression) single-injection PR #18870 (merged into release/v3.8.54 on 2026-11-10): the CCR engine no longer self-injects the protocol instruction (it is now injected once by the stacked pipeline, after all engines), so the MCP-capable with-tool case asserts the engine output is the single original user message with no self-injected system note instead of 2 messages + a system instruction: 3 asserts replaced, 1 net removed (20->19). The dropped 'instruction content non-empty' assert and the 'teach the retrieve tool contract' assert are covered by tests/unit/compression/ccr-protocol-pipeline.test.ts, which asserts the pipeline injects exactly one leading system note teaching the announced tool name. Behavior aligned to the single-injection contract, not masking. Prune once the release carrying #18870 (v3.8.54) merges to main (tracking: #20405).",
"tests/unit/ui/rtl-logical-classes.test.tsx": "ec27d84e (KEA-7886, F4, 2026-10-21): the legacy mobile sidebar drawer (.dashboard-sidebar-mobile, start-0/-translate-x-full RTL rules) was removed with the legacy shell; its six drawer cases were replaced by the Kit shell block in the same file, which asserts the kit Sidebar Sheet anchoring by side. Net 21 -> 19 is the realignment, not a weakening. Release-green base-red #17219 (2026-10-24).",
"tests/unit/routing-strategy-docs-sync-15159.test.ts": "PR #20162 (plan 2026-11-13 \"derived numbers resolved only at release\", phase 2, owner-approved): the agent-instruction files (AGENTS.md, open-sse/services/AGENTS.md, docs/i18n/bs/AGENTS.md) no longer state the routing-strategy count or an inline strategy list; they point to ROUTING_STRATEGY_VALUES in src/shared/constants/routingStrategies.ts. DOC-01's per-file 'count equals the code' and 'list names every strategy' asserts for those three files became 'points to the registry and carries no count or inline list' asserts (22 -> 17): the stale-count/stale-list failure mode #15159 guarded cannot occur there any more, and the counts gate's STRICT invariant 'No derived counts (agent-instruction file ...)' fails a count that comes back. The AUTO-COMBO.md count and full strategy-table asserts against the code are unchanged. No skip, tautology or deletion. Prune once the release carrying #20162 merges to main."
}

View File

@@ -94,7 +94,7 @@ loopback-only — `/api/plugins` and `/api/plugins/` are listed in
| Endpoint | Method | Description |
| -------------------------------- | ------ | --------------------------------------------------- |
| `/api/plugins` | GET | List installed plugins (optional `?status=` filter) |
| `/api/plugins` | POST | Install a plugin from the plugin sources directory |
| `/api/plugins` | POST | Install a plugin from an absolute local path |
| `/api/plugins/scan` | POST | Scan the plugin directory and register new plugins |
| `/api/plugins/marketplace` | GET | List marketplace catalog entries |
| `/api/plugins/[name]` | GET | Get installed plugin details |
@@ -123,20 +123,10 @@ curl -X POST http://localhost:20128/api/plugins \
-d '{ "path": "/absolute/path/to/my-plugin" }'
```
The `path` must be an **absolute** path to a directory **inside the plugin
sources directory**: `plugin-sources` next to the plugin root, so
`~/.omniroute/plugin-sources/` by default, or `<parent of OMNIROUTE_PLUGINS_DIR>/plugin-sources/`
when that variable is set (`getPluginSourcesDir()` in
`src/lib/plugins/installSource.ts`). Copy or clone the plugin there first. The
install is refused with `400` when the path contains `..` or a null byte, lies
outside that directory, resolves outside it through a symlink, contains a symlink
whose target is outside it, or when the directory does not exist. The source
directory must contain a valid `plugin.json` (or be a parent of one). On success
the response is `201` with the installed plugin row.
Unlike the other plugin routes, this one requires the management credential (a
dashboard session or a manage-scoped API key) even when login is disabled
(`requireLogin=false`): installing code is never an anonymous action.
The `path` must be **absolute** and may not contain `..` traversal segments or
null bytes (enforced by Zod). The source directory must contain a valid
`plugin.json` (or be a parent of one). On success the response is `201` with the
installed plugin row.
### Browse the marketplace
@@ -258,10 +248,6 @@ silently falls back to the built-in seed registry and logs a warning.
- **Env allowlist** — the child receives only an allowlisted set of environment
variables; the broader set is only granted when the manifest requests the
`env` permission.
- **Install source containment** — `POST /api/plugins` only reads from the plugin
sources directory (see "Install from a local path"): the path is canonicalized
with `realpath`, must stay strictly inside that directory, and a source tree
carrying a symlink that escapes it is refused before anything is copied.
- **Path containment** — install/upgrade/uninstall assert that the plugin
directory and `manifest.main` resolve **within** the managed plugin root
before any copy or recursive delete (guards against tampered DB paths and

View File

@@ -756,13 +756,15 @@ The cost: a real failure is blamed later, after the rest of the CI run plus the
often turn green on their re-run are flaky tests to fix.
**The App needs Actions: Read and write.** The tick job asks for `permission-actions: write` when
it mints its token. Grant it to the App, and accept it on the installation, before the version of
the queue that re-runs failed jobs reaches the default branch (see
[Installing the GitHub App](#installing-the-github-app), step 4). A token that reaches the tick
without it gets the call refused: the `checks-red` detail ends with `; re-run refused (<status>)`
(403 is GitHub's usual answer to a missing permission), and the batch is classified in the same
tick. Whether GitHub mints a token at all for an installation that lacks a
permission the job asks for has not been measured: it may fail every tick at the token step.
it mints its token. Grant it to the App, and accept it on the installation, before a tick runs with
this version of the workflow (see [Installing the GitHub App](#installing-the-github-app), step 4).
Without it GitHub mints no token at all. Asked for a permission the installation does not hold,
`POST /app/installations/{id}/access_tokens` answers 422, "The level of access for permissions
requested are not granted to this installation.", for the job's whole permission set (measured on
2026-11-17 against an installation with `actions: read`). So every tick fails at the step that
mints the token, not only the re-run, and no state is saved; the watchdog reports each base with
work after 90 minutes. A re-run GitHub refuses for any other reason ends the `checks-red` detail
with `; re-run refused (<status>)`, and the batch is classified in the same tick.
**Known limits.** These are accepted trade-offs of the current design, not bugs to work around:
@@ -1419,10 +1421,11 @@ action.
contains a PR touching a workflow would be rejected. **Actions** write lets the tick re-run the
failed jobs of a red candidate (`flakyReruns`), and the `tick` job of the workflow asks for it
when it mints the App token (`permission-actions: write`). Grant "Actions: Read and write" to
the App, and accept the new permission on the installation, **before** the version of the queue
that re-runs failed jobs reaches the default branch. What happens in the other order has not
been measured yet (a rehearsal will record it): an installation without that permission may
refuse to mint any token, which would fail every tick, not only the re-run. The watchdog does
the App, and accept the new permission on the installation, **before** a tick runs with this
version of the workflow: before OMNI_QUEUE_ENABLED is set or, where the queue is already
enabled, before this version reaches the default branch. In the other order GitHub refuses to
mint the tick's token (HTTP 422 for the job's whole permission set, measured on 2026-11-17), and
every tick fails at that step, not only the re-run. The watchdog does
not use the App: its workflow's own token has `contents: read`, `issues: write` and
`pull-requests: read`.
@@ -2265,8 +2268,9 @@ entries of each list while either is not empty. Check, in order:
1. Why GitHub refuses the App's status writes: the run's log names the error of each refused
write, and so does an `error` event (`<batchId>: could not withdraw …`, or the detail of the
failed tick's own `error` event when the tick threw). A revoked `statuses: write` permission of
the App, an uninstalled App or a GitHub incident are the usual causes.
failed tick's own `error` event when the tick threw). A GitHub incident is the usual cause. A
permission the App no longer holds, or an App that is no longer installed, does not get this
far: GitHub mints no token for the tick, which fails at that step and stores nothing.
2. Once that is fixed, wait until both lists are gone from `state/<sanitized-base>.json` on
`omni-queue-state` (the next ticks write the `failure` statuses). Nothing else needs a person.
3. Then `npm run queue -- resume <base>`. It is refused while `landWithdrawalsOverflow` holds

View File

@@ -5,11 +5,34 @@
*/
import { z } from "zod";
import { resolve, normalize, isAbsolute } from "path";
import { toSafeMcpErrorMessage } from "../errorMessage";
import { listPlugins, getPluginByName, updatePluginConfig } from "../../../src/lib/db/plugins";
import { pluginManager } from "../../../src/lib/plugins/manager";
import { validatePluginConfig, type ConfigField } from "../../../src/lib/plugins/manifest";
/**
* Validate a path is safe for plugin installation.
* Prevents directory traversal and null byte injection.
*/
function validatePluginPath(path: string): string {
// Reject null bytes
if (path.includes("\0")) {
throw new Error("Invalid path: contains null bytes");
}
// Must be absolute
if (!isAbsolute(path)) {
throw new Error("Path must be absolute");
}
// Normalize and resolve to prevent traversal
const normalized = normalize(resolve(path));
// Reject paths with traversal patterns
if (normalized.includes("..") || normalized.includes("~")) {
throw new Error("Invalid path: directory traversal detected");
}
return normalized;
}
export const pluginTools = [
{
name: "plugin_list",
@@ -41,19 +64,14 @@ export const pluginTools = [
{
name: "plugin_install",
description: "Install a plugin from a local directory inside the plugin sources directory.",
description: "Install a plugin from a local directory path.",
scopes: ["write:plugins"],
inputSchema: z.object({
path: z
.string()
.describe(
"Absolute path to a plugin directory (containing plugin.json) inside the plugin sources directory"
),
path: z.string().describe("Absolute path to the plugin directory containing plugin.json"),
}),
handler: async (args: { path: string }) => {
// Same containment as POST /api/plugins: the source must resolve inside the
// plugin sources directory (src/lib/plugins/installSource.ts).
const plugin = await pluginManager.installFromLocalSource(args.path);
const safePath = validatePluginPath(args.path);
const plugin = await pluginManager.install(safePath);
return {
success: true,
plugin: {

View File

@@ -3,7 +3,6 @@ import { CORS_HEADERS, handleCorsOptions } from "@/shared/utils/cors";
import { buildErrorBody } from "@omniroute/open-sse/utils/error";
import { listPlugins } from "@/lib/db/plugins";
import { pluginManager } from "@/lib/plugins/manager";
import { PluginInstallSourceError } from "@/lib/plugins/installSource";
import { requireManagementAuth } from "@/lib/api/requireManagementAuth";
import { z } from "zod";
@@ -41,12 +40,10 @@ export async function GET(request: NextRequest) {
}
/**
* POST /api/plugins — Install a plugin from a local path inside the plugin sources
* directory. Installing (and possibly activating) code is never anonymous, so the
* management credential is required even when login is disabled.
* POST /api/plugins — Install a plugin from a local path
*/
export async function POST(request: NextRequest) {
const authError = await requireManagementAuth(request, { alwaysRequireAuth: true });
const authError = await requireManagementAuth(request);
if (authError) return authError;
let body: unknown;
try {
@@ -58,13 +55,10 @@ export async function POST(request: NextRequest) {
);
}
const schema = z.object({
path: z
.string()
.min(1)
.refine(
(p) => !p.includes("\0") && !p.includes(".."),
"Path must not contain traversal patterns or null bytes"
),
path: z.string().min(1).regex(/^\/[^]*$/, "Path must be absolute").refine(
(p) => !p.includes("\0") && !p.includes(".."),
"Path must not contain traversal patterns or null bytes"
),
});
const parsed = schema.safeParse(body);
@@ -76,22 +70,12 @@ export async function POST(request: NextRequest) {
}
try {
const plugin = await pluginManager.installFromLocalSource(parsed.data.path);
const plugin = await pluginManager.install(parsed.data.path);
return NextResponse.json(
{ plugin: formatPlugin(plugin) },
{ status: 201, headers: CORS_HEADERS }
);
} catch (err: unknown) {
if (err instanceof PluginInstallSourceError) {
console.warn("[plugins] Refused plugin install source:", err.message);
return NextResponse.json(
buildErrorBody(
400,
"Plugin path must be an existing directory inside the plugin sources directory"
),
{ status: 400, headers: CORS_HEADERS }
);
}
console.error("[plugins] Failed to install plugin:", err);
return NextResponse.json(buildErrorBody(400, "Failed to install plugin"), {
status: 400,

View File

@@ -1,97 +0,0 @@
/**
* Install-source containment for the local-path plugin install.
*
* `POST /api/plugins` installs (and, with `enabledByDefault`, activates) the code
* found at a caller-supplied path. That path must live inside one operator-managed
* directory: the `plugin-sources` directory next to the plugin root
* (`~/.omniroute/plugin-sources` by default, or `<dirname(OMNIROUTE_PLUGINS_DIR)>/
* plugin-sources` when the plugin root is overridden). Anything else is refused.
*
* Every check fails closed: a missing root, a path that does not exist, a path that
* resolves (through symlinks) outside the root, or a symlink inside the source tree
* whose target escapes the root all reject the install.
*
* @module plugins/installSource
*/
import { lstat, readdir, realpath } from "fs/promises";
import { dirname, isAbsolute, join, resolve, sep } from "path";
export const PLUGIN_SOURCES_DIRNAME = "plugin-sources";
export class PluginInstallSourceError extends Error {
constructor(message: string) {
super(message);
this.name = "PluginInstallSourceError";
}
}
/** The directory local-path installs may read from, derived from the plugin root. */
export function getPluginSourcesDir(pluginDir: string): string {
return join(dirname(resolve(pluginDir)), PLUGIN_SOURCES_DIRNAME);
}
function isStrictlyInside(root: string, target: string): boolean {
return target.startsWith(root + sep);
}
async function assertNoEscapingSymlinks(dir: string, realRoot: string): Promise<void> {
const entries = await readdir(dir, { recursive: true, withFileTypes: true });
for (const entry of entries) {
if (!entry.isSymbolicLink()) continue;
const entryPath = join(entry.parentPath, entry.name);
const target = await realpath(entryPath).catch(() => null);
if (!target || !isStrictlyInside(realRoot, target)) {
throw new PluginInstallSourceError(
"Plugin source contains a symlink that resolves outside the plugin sources directory"
);
}
}
}
/**
* Validate a caller-supplied install path against the plugin sources root and
* return its canonical (symlink-free) form, which is what the installer must use.
*/
export async function resolvePluginInstallSource(
requestedPath: string,
sourcesRoot: string
): Promise<string> {
if (
typeof requestedPath !== "string" ||
requestedPath.length === 0 ||
requestedPath.includes("\0") ||
!isAbsolute(requestedPath)
) {
throw new PluginInstallSourceError("Plugin path must be an absolute path");
}
const root = resolve(sourcesRoot);
const realRoot = await realpath(root).catch(() => null);
if (!realRoot) {
throw new PluginInstallSourceError("Plugin sources directory does not exist");
}
// Lexical check first, so a path outside the root is refused without ever being
// touched on disk (no existence probe of arbitrary host paths).
const lexical = resolve(requestedPath);
if (!isStrictlyInside(root, lexical) && !isStrictlyInside(realRoot, lexical)) {
throw new PluginInstallSourceError("Plugin path is outside the plugin sources directory");
}
const realSource = await realpath(requestedPath).catch(() => null);
if (!realSource) {
throw new PluginInstallSourceError("Plugin path does not exist");
}
if (!isStrictlyInside(realRoot, realSource)) {
throw new PluginInstallSourceError("Plugin path is outside the plugin sources directory");
}
const info = await lstat(realSource);
if (!info.isDirectory()) {
throw new PluginInstallSourceError("Plugin path must be a directory");
}
await assertNoEscapingSymlinks(realSource, realRoot);
return realSource;
}

View File

@@ -13,7 +13,6 @@ import { join, dirname, resolve, sep } from "path";
import { randomUUID } from "crypto";
import { logger } from "../../../open-sse/utils/logger.ts";
import { getDefaultPluginDir, scanPluginDir } from "./scanner";
import { getPluginSourcesDir, resolvePluginInstallSource } from "./installSource";
import { loadPlugin, type LoadedPlugin } from "./loader";
import { registerHook, unregisterHooks, emitHook, type HookHandler, type Plugin } from "./hooks";
import {
@@ -122,21 +121,6 @@ class PluginManager {
return PluginManager.instance;
}
/** Directory that caller-supplied local install paths must live in. */
getSourcesDir(): string {
return getPluginSourcesDir(this.pluginDir);
}
/**
* Install from a caller-supplied local path (POST /api/plugins). The path must
* resolve inside {@link getSourcesDir}; see ./installSource for the checks.
* Throws PluginInstallSourceError when the path is refused.
*/
async installFromLocalSource(requestedPath: string): Promise<PluginRow> {
const source = await resolvePluginInstallSource(requestedPath, this.getSourcesDir());
return this.install(source);
}
/**
* Install a plugin from a source directory.
* Copies to a staging dir first, validates manifest.main containment, then

View File

@@ -7,10 +7,9 @@
* must surface as a clean 400, while a well-formed body keeps its existing behavior.
*
* DB setup mirrors tests/unit/api-malformed-json-400.test.ts: a temp DATA_DIR with no
* configured password. Both POST /api/plugins and PATCH /api/relay/tokens/[id] always
* require management auth, so their requests carry a manage-scoped API key, as in
* tests/unit/relay-tokens-always-protected.test.ts; the relay requests target a seeded
* token. DB handles
* configured password, so POST /api/plugins needs no login. PATCH /api/relay/tokens/[id]
* always requires management auth, so its requests carry a manage-scoped API key, as in
* tests/unit/relay-tokens-always-protected.test.ts, and target a seeded token. DB handles
* are released in test.after (resetDbInstance), as unreleased SQLite handles hang the runner.
*/
@@ -70,21 +69,14 @@ test.after(() => {
test("POST /api/plugins — malformed JSON body returns 400", async () => {
const res = await pluginsRoute.POST(
managedJsonRequest("http://localhost/api/plugins", "POST", "not-json") as never
jsonRequest("http://localhost/api/plugins", "POST", "not-json") as never
);
assert.equal(res.status, 400);
});
test("POST /api/plugins — malformed JSON without credentials is still 401", async () => {
const res = await pluginsRoute.POST(
jsonRequest("http://localhost/api/plugins", "POST", "not-json") as never
);
assert.equal(res.status, 401);
});
test("POST /api/plugins — well-formed but invalid body still returns 400", async () => {
const res = await pluginsRoute.POST(
managedJsonRequest("http://localhost/api/plugins", "POST", JSON.stringify({})) as never
jsonRequest("http://localhost/api/plugins", "POST", JSON.stringify({})) as never
);
assert.equal(res.status, 400);
const body = (await res.json()) as { error?: string };

View File

@@ -1,172 +0,0 @@
// POST /api/plugins installs — and, with `enabledByDefault`, activates — the code at a
// caller-supplied path. Two guarantees are pinned here:
// 1. the install source must live inside the operator-managed `plugin-sources`
// directory next to the plugin root; any other absolute path, a path that
// resolves outside it through a symlink, or a source tree carrying a symlink
// that escapes it is refused before anything is copied;
// 2. the route needs a management credential even when login is disabled
// (requireLogin=false): "anonymous" is never the right audience for
// "install and run this code on the host".
import test from "node:test";
import assert from "node:assert/strict";
import fs from "node:fs";
import os from "node:os";
import path from "node:path";
import { makeManagementSessionRequest } from "../helpers/managementSession.ts";
const BASE_DIR = fs.mkdtempSync(
path.join(process.env.DATA_DIR || os.tmpdir(), "plugin-src-guard-")
);
const PLUGIN_ROOT = path.join(BASE_DIR, "plugins");
const SOURCES_ROOT = path.join(BASE_DIR, "plugin-sources");
const OUTSIDE_ROOT = path.join(BASE_DIR, "outside");
fs.mkdirSync(PLUGIN_ROOT, { recursive: true });
fs.mkdirSync(SOURCES_ROOT, { recursive: true });
fs.mkdirSync(OUTSIDE_ROOT, { recursive: true });
const ORIGINAL_ENV = {
OMNIROUTE_PLUGINS_DIR: process.env.OMNIROUTE_PLUGINS_DIR,
JWT_SECRET: process.env.JWT_SECRET,
API_KEY_SECRET: process.env.API_KEY_SECRET,
};
process.env.OMNIROUTE_PLUGINS_DIR = PLUGIN_ROOT;
process.env.JWT_SECRET = "plugin-src-guard-jwt-secret";
process.env.API_KEY_SECRET = "plugin-src-guard-api-key-secret";
const core = await import("../../src/lib/db/core.ts");
const pluginsDb = await import("../../src/lib/db/plugins.ts");
const { updateSettings } = await import("../../src/lib/db/settings.ts");
const pluginsRoute = await import("../../src/app/api/plugins/route.ts");
const loadInstallSource = () => import("../../src/lib/plugins/installSource.ts");
const URL_PLUGINS = "http://localhost:20128/api/plugins";
test.after(() => {
core.resetDbInstance();
fs.rmSync(BASE_DIR, { recursive: true, force: true, maxRetries: 5, retryDelay: 100 });
for (const [key, value] of Object.entries(ORIGINAL_ENV)) {
if (value === undefined) delete process.env[key];
else process.env[key] = value;
}
});
function writePlugin(parent: string, name: string): string {
const dir = path.join(parent, name);
fs.mkdirSync(dir, { recursive: true });
fs.writeFileSync(
path.join(dir, "plugin.json"),
JSON.stringify({ name, version: "1.0.0", main: "index.js" })
);
fs.writeFileSync(path.join(dir, "index.js"), "module.exports = {};\n");
return dir;
}
function anonymousPost(body: unknown): Request {
return new Request(URL_PLUGINS, {
method: "POST",
headers: { "content-type": "application/json" },
body: JSON.stringify(body),
});
}
function sessionPost(body: unknown): Promise<Request> {
return makeManagementSessionRequest(URL_PLUGINS, { method: "POST", body: body as never });
}
async function assertRefused(response: Response, status: number): Promise<void> {
const text = await response.text();
assert.equal(response.status, status, `expected ${status}, got ${response.status}: ${text}`);
assert.ok(!text.includes("at /"), "error body must not leak a stack trace");
}
test("getPluginSourcesDir is the plugin-sources sibling of the plugin root", async () => {
const installSource = await loadInstallSource();
assert.equal(installSource.getPluginSourcesDir(PLUGIN_ROOT), SOURCES_ROOT);
});
test("resolvePluginInstallSource refuses paths outside the sources root", async () => {
const installSource = await loadInstallSource();
const outside = writePlugin(OUTSIDE_ROOT, "outside-direct");
const cases = [
outside,
"/etc",
"relative/plugin",
"",
`${SOURCES_ROOT}/../outside/outside-direct`,
SOURCES_ROOT,
`${SOURCES_ROOT}-sibling/x`,
`${SOURCES_ROOT}/x\0y`,
];
for (const candidate of cases) {
await assert.rejects(
installSource.resolvePluginInstallSource(candidate, SOURCES_ROOT),
installSource.PluginInstallSourceError,
`must refuse ${JSON.stringify(candidate)}`
);
}
});
test("resolvePluginInstallSource refuses symlinks that escape the sources root", async () => {
const installSource = await loadInstallSource();
const outside = writePlugin(OUTSIDE_ROOT, "outside-linked");
const linkedDir = path.join(SOURCES_ROOT, "linked-dir");
fs.symlinkSync(outside, linkedDir, "dir");
await assert.rejects(
installSource.resolvePluginInstallSource(linkedDir, SOURCES_ROOT),
installSource.PluginInstallSourceError
);
const inner = writePlugin(SOURCES_ROOT, "inner-escape");
fs.mkdirSync(path.join(inner, "lib"));
fs.symlinkSync(path.join(outside, "index.js"), path.join(inner, "lib", "evil.js"));
await assert.rejects(
installSource.resolvePluginInstallSource(inner, SOURCES_ROOT),
installSource.PluginInstallSourceError
);
});
test("resolvePluginInstallSource fails closed when the sources root does not exist", async () => {
const installSource = await loadInstallSource();
const missingRoot = path.join(BASE_DIR, "missing-root");
await assert.rejects(
installSource.resolvePluginInstallSource(path.join(missingRoot, "p"), missingRoot),
installSource.PluginInstallSourceError
);
});
test("resolvePluginInstallSource accepts a plugin directory inside the sources root", async () => {
const installSource = await loadInstallSource();
const good = writePlugin(SOURCES_ROOT, "inside-ok");
fs.symlinkSync(path.join(good, "index.js"), path.join(good, "alias.js"));
const resolved = await installSource.resolvePluginInstallSource(good, SOURCES_ROOT);
assert.equal(resolved, fs.realpathSync(good));
});
test("POST /api/plugins refuses an install source outside the plugin sources directory", async () => {
const outside = writePlugin(OUTSIDE_ROOT, "route-outside");
const response = await pluginsRoute.POST((await sessionPost({ path: outside })) as never);
await assertRefused(response, 400);
assert.equal(pluginsDb.getPluginByName("route-outside"), null, "nothing may be installed");
assert.equal(fs.existsSync(path.join(PLUGIN_ROOT, "route-outside")), false);
});
test("POST /api/plugins installs from inside the plugin sources directory", async () => {
const good = writePlugin(SOURCES_ROOT, "route-inside");
const response = await pluginsRoute.POST((await sessionPost({ path: good })) as never);
const text = await response.text();
assert.equal(response.status, 201, text);
assert.equal(JSON.parse(text).plugin.name, "route-inside");
assert.ok(pluginsDb.getPluginByName("route-inside"));
});
test("with login disabled, an anonymous POST /api/plugins is refused", async () => {
const good = writePlugin(SOURCES_ROOT, "route-anon");
await updateSettings({ requireLogin: false });
try {
const response = await pluginsRoute.POST(anonymousPost({ path: good }) as never);
await assertRefused(response, 401);
assert.equal(pluginsDb.getPluginByName("route-anon"), null, "nothing may be installed");
} finally {
await updateSettings({ requireLogin: true });
}
});

View File

@@ -22,11 +22,10 @@ function getTool(name: string) {
return tool!;
}
function writeTestPlugin(opts?: { name?: string; onRequest?: boolean; parent?: string }) {
function writeTestPlugin(opts?: { name?: string; onRequest?: boolean }) {
const name = opts?.name ?? "test-tools-plugin";
const onRequest = opts?.onRequest ?? true;
if (opts?.parent) fs.mkdirSync(opts.parent, { recursive: true });
const sourceDir = fs.mkdtempSync(path.join(opts?.parent ?? os.tmpdir(), "omniroute-plugin-src-"));
const sourceDir = fs.mkdtempSync(path.join(os.tmpdir(), "omniroute-plugin-src-"));
const pluginDir = path.join(sourceDir, name);
fs.mkdirSync(pluginDir, { recursive: true });
const manifest = {
@@ -127,12 +126,8 @@ test("plugin_list: filters by status", async () => {
// ── plugin_install ──
test("plugin_install: installs a valid plugin from the plugin sources directory", async () => {
const { pluginManager } = await import("../../src/lib/plugins/manager.ts");
const { sourceDir, name } = writeTestPlugin({
name: "install-tool",
parent: pluginManager.getSourcesDir(),
});
test("plugin_install: installs a valid plugin", async () => {
const { sourceDir, name } = writeTestPlugin({ name: "install-tool" });
activeSourceDirs.push(sourceDir);
const tool = getTool("plugin_install");
@@ -140,30 +135,16 @@ test("plugin_install: installs a valid plugin from the plugin sources directory"
assert.equal(result.success, true);
assert.equal(result.plugin.name, name);
const { pluginManager } = await import("../../src/lib/plugins/manager.ts");
await pluginManager.uninstall(name);
});
test("plugin_install: refuses a path outside the plugin sources directory", async () => {
const { sourceDir, name } = writeTestPlugin({ name: "install-tool-outside" });
activeSourceDirs.push(sourceDir);
const tool = getTool("plugin_install");
await assert.rejects(
() => tool.handler({ path: sourceDir }),
(err: Error) => {
assert.equal(err.name, "PluginInstallSourceError");
return true;
}
);
assert.equal(dbPlugins.getPluginByName(name), null, "nothing may be installed");
});
test("plugin_install: throws for invalid path", async () => {
const tool = getTool("plugin_install");
await assert.rejects(
() => tool.handler({ path: "/nonexistent/path" }),
(err: Error) => {
assert.equal(err.name, "PluginInstallSourceError");
assert.ok(err.message.includes("No valid plugin found"));
return true;
}
);