sortie-dogs 0.1.1

package/dist/plugin/config.js

@@ -0,0 +1,173 @@
+import { BUILT_IN_MODEL_CATALOG, DEDICATED_SOL_ROUTING, RECOMMENDED_LUNA_ROUTING, isDedicatedSolRole, parseModelRoutingConfig, } from "./model-routing.js";
+export const DEFAULT_PLUGIN_OPTIONS = {
+    operationManifestPath: "operation-manifest.json",
+    handoffPaths: ["handoff.json"],
+    modelRouting: RECOMMENDED_LUNA_ROUTING,
+    modelCatalog: BUILT_IN_MODEL_CATALOG,
+};
+function isRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function nonEmptyString(value) {
+    return typeof value === "string" && value.length > 0;
+}
+function parseCatalogModels(value) {
+    if (!Array.isArray(value))
+        return undefined;
+    const models = [];
+    for (const candidate of value) {
+        if (!isRecord(candidate) || Object.keys(candidate).some((key) => key !== "model" && key !== "variants")) {
+            return undefined;
+        }
+        if (!nonEmptyString(candidate.model))
+            return undefined;
+        if (candidate.variants !== undefined &&
+            (!Array.isArray(candidate.variants) || candidate.variants.some((variant) => !nonEmptyString(variant))))
+            return undefined;
+        models.push(candidate.variants === undefined
+            ? { model: candidate.model }
+            : { model: candidate.model, variants: candidate.variants });
+    }
+    return models;
+}
+function parseModelCatalog(value) {
+    if (!isRecord(value) || Object.keys(value).some((key) => key !== "project" && key !== "global")) {
+        return undefined;
+    }
+    const project = value.project === undefined ? undefined : parseCatalogModels(value.project);
+    const global = value.global === undefined ? undefined : parseCatalogModels(value.global);
+    if (value.project !== undefined && project === undefined)
+        return undefined;
+    if (value.global !== undefined && global === undefined)
+        return undefined;
+    return {
+        ...(project === undefined ? {} : { project }),
+        ...(global === undefined ? {} : { global }),
+    };
+}
+function mergeCatalogModels(builtIn, configured) {
+    const models = new Map();
+    for (const candidate of [...builtIn, ...configured]) {
+        if (!models.has(candidate.model)) {
+            models.set(candidate.model, candidate.variants === undefined
+                ? undefined
+                : new Set(candidate.variants));
+            continue;
+        }
+        if (candidate.variants === undefined)
+            continue;
+        const variants = models.get(candidate.model);
+        if (variants === undefined) {
+            models.set(candidate.model, new Set(candidate.variants));
+        }
+        else {
+            for (const variant of candidate.variants)
+                variants.add(variant);
+        }
+    }
+    return [...models].map(([model, variants]) => variants === undefined
+        ? { model }
+        : { model, variants: [...variants] });
+}
+function parseLayer(value) {
+    if (value === undefined)
+        return {};
+    if (!isRecord(value))
+        return undefined;
+    if (Object.keys(value).some((key) => key !== "operationManifestPath" && key !== "handoffPaths" && key !== "modelRouting" && key !== "modelCatalog")) {
+        return undefined;
+    }
+    const manifestPath = value.operationManifestPath;
+    const handoffPaths = value.handoffPaths;
+    const modelRouting = value.modelRouting === undefined
+        ? undefined
+        : parseModelRoutingConfig(value.modelRouting);
+    const modelCatalog = value.modelCatalog === undefined
+        ? undefined
+        : parseModelCatalog(value.modelCatalog);
+    if (manifestPath !== undefined && (typeof manifestPath !== "string" || manifestPath.length === 0)) {
+        return undefined;
+    }
+    if (handoffPaths !== undefined &&
+        (!Array.isArray(handoffPaths) || handoffPaths.some((path) => typeof path !== "string" || path.length === 0))) {
+        return undefined;
+    }
+    if (value.modelRouting !== undefined && modelRouting === undefined)
+        return undefined;
+    if (value.modelCatalog !== undefined && modelCatalog === undefined)
+        return undefined;
+    return {
+        operationManifestPath: manifestPath,
+        handoffPaths: handoffPaths,
+        modelRouting,
+        modelCatalog,
+    };
+}
+/** Merge defaults, optional project/env configuration, then the host override. */
+export function resolvePluginConfiguration(...values) {
+    let operationManifestPath = DEFAULT_PLUGIN_OPTIONS.operationManifestPath;
+    let handoffPaths = DEFAULT_PLUGIN_OPTIONS.handoffPaths;
+    let modelRouting = DEFAULT_PLUGIN_OPTIONS.modelRouting;
+    let modelCatalog = DEFAULT_PLUGIN_OPTIONS.modelCatalog;
+    for (const value of values) {
+        const layer = parseLayer(value);
+        if (layer === undefined)
+            return { kind: "invalid" };
+        if (layer.operationManifestPath !== undefined)
+            operationManifestPath = layer.operationManifestPath;
+        if (layer.handoffPaths !== undefined)
+            handoffPaths = layer.handoffPaths;
+        if (layer.modelRouting !== undefined) {
+            modelRouting = { ...modelRouting, ...layer.modelRouting };
+        }
+        if (layer.modelCatalog !== undefined) {
+            modelCatalog = {
+                ...modelCatalog,
+                ...layer.modelCatalog,
+                ...(layer.modelCatalog.global === undefined ? {} : {
+                    global: mergeCatalogModels(BUILT_IN_MODEL_CATALOG.global ?? [], layer.modelCatalog.global),
+                }),
+            };
+        }
+    }
+    const hasRouting = Object.keys(modelRouting).length > 0;
+    const hasCatalogEntries = (modelCatalog.project?.length ?? 0) + (modelCatalog.global?.length ?? 0) > 0;
+    if (hasRouting && !hasCatalogEntries)
+        return { kind: "invalid" };
+    return {
+        kind: "configured",
+        operationManifestPath,
+        handoffPaths,
+        modelRouting,
+        modelCatalog,
+    };
+}
+/** Resolve the plugin's fixed source boundaries: project-local first, environment and host global. */
+export function resolvePluginConfigurationSources(projectValue, environmentValue, hostValue) {
+    const configured = resolvePluginConfiguration(projectValue, environmentValue, hostValue);
+    if (configured.kind === "invalid")
+        return configured;
+    const projectLayer = parseLayer(projectValue);
+    const environmentLayer = parseLayer(environmentValue);
+    const hostLayer = parseLayer(hostValue);
+    if (projectLayer === undefined || environmentLayer === undefined || hostLayer === undefined) {
+        return { kind: "invalid" };
+    }
+    const globalModelRouting = Object.fromEntries(Object.entries({
+        ...RECOMMENDED_LUNA_ROUTING,
+        ...(environmentLayer.modelRouting ?? {}),
+        ...(hostLayer.modelRouting ?? {}),
+    }).filter(([role]) => !isDedicatedSolRole(role)));
+    const modelRouting = {
+        ...Object.fromEntries(Object.entries(configured.modelRouting)
+            .filter(([role]) => !isDedicatedSolRole(role))),
+        ...DEDICATED_SOL_ROUTING,
+    };
+    return {
+        ...configured,
+        modelRouting,
+        // Mk2A2 worker policy is authoritative over every configurable layer.
+        localModelRouting: { ...(projectLayer.modelRouting ?? {}), ...DEDICATED_SOL_ROUTING },
+        globalModelRouting,
+    };
+}

package/dist/plugin/gate.d.ts

@@ -0,0 +1,38 @@
+export interface ToolExecuteBeforeInput {
+    tool: string;
+    sessionID: string;
+    callID: string;
+}
+export interface ToolExecuteBeforeOutput {
+    args: unknown;
+}
+export type WriteDenialReason = "manifest-unavailable" | "path-required" | "project-boundary" | "manifest-scope";
+export declare class WriteDeniedError extends Error {
+    readonly reason: WriteDenialReason;
+    constructor(reason: WriteDenialReason, path: string, options?: ErrorOptions);
+}
+export interface ProjectPaths {
+    readonly root: string;
+    absolute(relativePath: string): string;
+    toRelativePath(path: string): Promise<string>;
+}
+export interface WriteGate {
+    check(input: ToolExecuteBeforeInput, output: ToolExecuteBeforeOutput): Promise<void>;
+    checkPath(path: string): Promise<void>;
+    toRelativePath(path: string): Promise<string>;
+}
+interface Extraction {
+    applies: boolean;
+    ambiguous: boolean;
+    paths: string[];
+}
+export declare function safePath(path: string): string;
+export declare function resolveProjectRoot(input: {
+    directory: string;
+    worktree?: string;
+}): string;
+/** Extract known write destinations; unknown shell executables fail closed as ambiguous. */
+export declare function extractWritePaths(tool: string, args: unknown): Extraction;
+export declare function createProjectPaths(rootCandidate: string): Promise<ProjectPaths>;
+export declare function createWriteGate(project: ProjectPaths, value: unknown): Promise<WriteGate>;
+export {};

package/dist/plugin/gate.js

@@ -0,0 +1,320 @@
+import { lstat, realpath } from "node:fs/promises";
+import { isAbsolute, relative, resolve } from "node:path";
+import { RelativePathError, normalizeRelativePath } from "../core/path.js";
+import { validateOperationManifestSchema } from "../core/validate-schema.js";
+export class WriteDeniedError extends Error {
+    reason;
+    constructor(reason, path, options) {
+        const messages = {
+            "manifest-unavailable": "operation manifest unavailable.",
+            "path-required": "write path must be explicit.",
+            "project-boundary": "project-root-relative path required.",
+            "manifest-scope": "operation manifest write scope.",
+        };
+        super(`Write denied for "${safePath(path)}": ${messages[reason]}`, options);
+        this.name = "WriteDeniedError";
+        this.reason = reason;
+    }
+}
+const DIRECT_PATH_KEYS = new Set([
+    "file", "filepath", "file_path", "path", "destination", "target",
+]);
+const ALL_OPERAND_COMMANDS = new Set(["mkdir", "rm", "rmdir", "touch", "truncate", "unlink"]);
+const LAST_OPERAND_COMMANDS = new Set(["cp", "install"]);
+const READ_ONLY_COMMANDS = new Set([
+    "cat", "echo", "false", "get-childitem", "get-content", "grep", "head", "ls", "pwd",
+    "rg", "stat", "tail", "test-path", "true", "type", "wc",
+]);
+const READ_ONLY_GIT_COMMANDS = new Set(["diff", "log", "ls-files", "rev-parse", "show", "status"]);
+const POWERSHELL_WRITE_COMMANDS = new Set([
+    "add-content", "copy-item", "move-item", "new-item", "out-file", "remove-item",
+    "rename-item", "set-content",
+]);
+const READ_ONLY_OPTIONS_WITH_VALUES = new Set(["-c", "--directory", "--exclude", "--include"]);
+function isRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+export function safePath(path) {
+    return [...path].map((character) => {
+        const code = character.codePointAt(0);
+        return code <= 0x1f || (code >= 0x7f && code <= 0x9f) ? "?" : character;
+    }).join("").slice(0, 512);
+}
+export function resolveProjectRoot(input) {
+    return resolve(input.directory);
+}
+function directPaths(args) {
+    if (!isRecord(args))
+        return [];
+    const paths = [];
+    for (const [key, value] of Object.entries(args)) {
+        if (DIRECT_PATH_KEYS.has(key.toLowerCase()) && typeof value === "string")
+            paths.push(value);
+        if (/^(?:files|paths|destinations|targets)$/iu.test(key) && Array.isArray(value)) {
+            paths.push(...value.filter((item) => typeof item === "string"));
+        }
+    }
+    return paths;
+}
+function patchPaths(patch) {
+    const paths = [];
+    for (const line of patch.split(/\r?\n/u)) {
+        const envelope = /^\*\*\* (?:Add|Update|Delete) File:\s*(.+?)\s*$/u.exec(line) ??
+            /^\*\*\* Move to:\s*(.+?)\s*$/u.exec(line);
+        if (envelope !== null)
+            paths.push(envelope[1]);
+        const unified = /^\+\+\+\s+(?:b\/)?(.+?)\s*$/u.exec(line);
+        if (unified !== null && unified[1] !== "/dev/null")
+            paths.push(unified[1]);
+    }
+    return paths;
+}
+function unquote(value) {
+    if ((value.startsWith('"') && value.endsWith('"')) ||
+        (value.startsWith("'") && value.endsWith("'")))
+        return value.slice(1, -1);
+    return value;
+}
+function words(command) {
+    return command.match(/"(?:\\.|[^"])*"|'[^']*'|[^\s]+/gu)?.map(unquote) ?? [];
+}
+function operands(tokens) {
+    const result = [];
+    for (let index = 1; index < tokens.length; index += 1) {
+        const token = tokens[index];
+        if (/^(?:\d*>>?|>\||[|&])(?:.*)?$/u.test(token))
+            break;
+        if (READ_ONLY_OPTIONS_WITH_VALUES.has(token))
+            index += 1;
+        else if (!token.startsWith("-"))
+            result.push(token.replace(/[|&;]+$/u, ""));
+    }
+    return result.filter(Boolean);
+}
+function unwrapEnvironmentCommand(tokens) {
+    const executable = tokens[0]?.replaceAll("\\", "/").split("/").at(-1)?.toLowerCase();
+    if (executable !== "env")
+        return tokens;
+    let index = 1;
+    while (index < tokens.length) {
+        const token = tokens[index];
+        if (token === "-u" || token === "--unset") {
+            index += 2;
+        }
+        else if (token.startsWith("--unset=") || /^[A-Za-z_][A-Za-z0-9_]*=/u.test(token)) {
+            index += 1;
+        }
+        else {
+            break;
+        }
+    }
+    return tokens.slice(index);
+}
+function isRemoteOnlyGitHubCommand(tokens) {
+    const command = tokens[1]?.toLowerCase();
+    return command === "project" || (command === "api" && tokens[2]?.toLowerCase() === "graphql");
+}
+function isReadOnlyGitCommand(tokens) {
+    const command = tokens[1]?.toLowerCase() ?? "";
+    return READ_ONLY_GIT_COMMANDS.has(command) ||
+        (command === "branch" && tokens.length === 3 && tokens[2] === "--show-current");
+}
+function shellPaths(command) {
+    const paths = [];
+    let applies = false;
+    let ambiguous = false;
+    const redirection = /(?:^|[\s;&|])(?:\d*)(?:>>?|>\|)\s*("(?:\\.|[^"])*"|'[^']*'|[^\s;&|]+)/gu;
+    for (const match of command.matchAll(redirection)) {
+        applies = true;
+        paths.push(unquote(match[1]));
+    }
+    for (const segment of command.split(/(?:&&|\|\||(?<!>)\|(?!\|)|;|\r?\n)/u)) {
+        const tokens = unwrapEnvironmentCommand(words(segment.trim()));
+        if (tokens.length === 0)
+            continue;
+        const executable = tokens[0].replaceAll("\\", "/").split("/").at(-1).toLowerCase();
+        const commandOperands = operands(tokens);
+        if (ALL_OPERAND_COMMANDS.has(executable)) {
+            applies = true;
+            paths.push(...commandOperands);
+        }
+        else if (LAST_OPERAND_COMMANDS.has(executable)) {
+            applies = true;
+            const destination = commandOperands.at(-1);
+            if (destination === undefined)
+                ambiguous = true;
+            else
+                paths.push(destination);
+        }
+        else if (executable === "mv") {
+            applies = true;
+            if (commandOperands.length < 2)
+                ambiguous = true;
+            paths.push(...commandOperands);
+        }
+        else if (executable === "tee") {
+            applies = true;
+            if (commandOperands.length === 0)
+                ambiguous = true;
+            paths.push(...commandOperands);
+        }
+        else if (POWERSHELL_WRITE_COMMANDS.has(executable)) {
+            applies = true;
+            const named = [];
+            for (let index = 1; index < tokens.length - 1; index += 1) {
+                if (/^-(?:path|literalpath|destination)$/iu.test(tokens[index]))
+                    named.push(tokens[index + 1]);
+            }
+            const selected = named.length > 0 ? named : commandOperands.slice(0, 1);
+            if (selected.length === 0)
+                ambiguous = true;
+            paths.push(...selected);
+        }
+        else if (/^(?:apply_?patch)$/iu.test(executable)) {
+            applies = true;
+            const selected = patchPaths(segment);
+            if (selected.length === 0)
+                ambiguous = true;
+            paths.push(...selected);
+        }
+        else if (executable === "git" && isReadOnlyGitCommand(tokens)) {
+            // Explicitly read-only git subcommands.
+        }
+        else if (/^gh(?:\.exe)?$/u.test(executable) && isRemoteOnlyGitHubCommand(tokens)) {
+            // GitHub Project commands mutate remote state, not project files. Redirections remain gated above.
+        }
+        else if (!READ_ONLY_COMMANDS.has(executable)) {
+            applies = true;
+            ambiguous = true;
+        }
+    }
+    return { applies, ambiguous, paths };
+}
+/** Extract known write destinations; unknown shell executables fail closed as ambiguous. */
+export function extractWritePaths(tool, args) {
+    const name = tool.toLowerCase();
+    const paths = directPaths(args);
+    if (/^(?:write|edit)(?:$|[_-])/u.test(name))
+        return { applies: true, ambiguous: paths.length === 0, paths };
+    if (/patch/u.test(name)) {
+        const patch = isRecord(args) && typeof args.patchText === "string"
+            ? args.patchText
+            : isRecord(args) && typeof args.patch === "string" ? args.patch : undefined;
+        const extracted = patch === undefined ? [] : patchPaths(patch);
+        return { applies: true, ambiguous: extracted.length === 0, paths: [...paths, ...extracted] };
+    }
+    if (/^(?:bash|shell|powershell|pwsh)(?:$|[_-])/u.test(name)) {
+        const command = isRecord(args) && typeof args.command === "string" ? args.command : undefined;
+        if (command === undefined)
+            return { applies: paths.length > 0, ambiguous: paths.length === 0, paths };
+        const extracted = shellPaths(command);
+        return {
+            applies: extracted.applies || paths.length > 0,
+            ambiguous: extracted.ambiguous,
+            paths: [...paths, ...extracted.paths],
+        };
+    }
+    return { applies: false, ambiguous: false, paths: [] };
+}
+async function nearestExistingRealPath(path) {
+    let candidate = path;
+    while (true) {
+        try {
+            await lstat(candidate);
+        }
+        catch (error) {
+            if (!isRecord(error) || error.code !== "ENOENT")
+                throw error;
+            const parent = resolve(candidate, "..");
+            if (parent === candidate)
+                throw error;
+            candidate = parent;
+            continue;
+        }
+        return await realpath(candidate);
+    }
+}
+function isWithin(root, target) {
+    const path = relative(root, target);
+    return path === "" || (!path.startsWith("..") && !isAbsolute(path));
+}
+export async function createProjectPaths(rootCandidate) {
+    const root = resolve(rootCandidate);
+    const realRoot = await realpath(root);
+    return {
+        root,
+        absolute: (relativePath) => resolve(root, relativePath),
+        async toRelativePath(path) {
+            const relativePath = isAbsolute(path) ? relative(root, resolve(path)) : path;
+            const normalized = normalizeRelativePath(relativePath);
+            const absolute = resolve(root, normalized);
+            if (!isWithin(root, absolute) || !isWithin(realRoot, await nearestExistingRealPath(absolute))) {
+                throw new WriteDeniedError("project-boundary", normalized);
+            }
+            return normalized;
+        },
+    };
+}
+export async function createWriteGate(project, value) {
+    const validated = validateOperationManifestSchema(value);
+    if (!validated.ok)
+        throw new WriteDeniedError("manifest-unavailable", "<unknown>");
+    const manifest = validated.value;
+    const writable = new Set(manifest.write.map((path) => normalizeRelativePath(path)));
+    const writableDirectories = [];
+    for (const path of writable) {
+        try {
+            const metadata = await lstat(project.absolute(path));
+            if (metadata.isDirectory()) {
+                writableDirectories.push({ path, realPath: await realpath(project.absolute(path)) });
+            }
+        }
+        catch {
+            // Missing, inaccessible, and concurrently changed paths remain exact-only scopes.
+        }
+    }
+    const isWritable = async (normalized) => {
+        if (writable.has(normalized))
+            return true;
+        const scopes = writableDirectories.filter((scope) => normalized.startsWith(`${scope.path}/`));
+        if (scopes.length === 0)
+            return false;
+        try {
+            const realTarget = await nearestExistingRealPath(project.absolute(normalized));
+            return scopes.some((scope) => isWithin(scope.realPath, realTarget));
+        }
+        catch {
+            return false;
+        }
+    };
+    const checkPath = async (path) => {
+        let normalized;
+        try {
+            normalized = await project.toRelativePath(path);
+        }
+        catch (error) {
+            if (error instanceof WriteDeniedError)
+                throw error;
+            if (error instanceof RelativePathError) {
+                throw new WriteDeniedError("project-boundary", path, { cause: error });
+            }
+            throw error;
+        }
+        if (!await isWritable(normalized))
+            throw new WriteDeniedError("manifest-scope", normalized);
+    };
+    return {
+        checkPath,
+        toRelativePath: project.toRelativePath,
+        async check(_input, output) {
+            const extracted = extractWritePaths(_input.tool, output.args);
+            if (!extracted.applies)
+                return;
+            if (extracted.ambiguous || extracted.paths.length === 0) {
+                throw new WriteDeniedError("path-required", "<unknown>");
+            }
+            for (const path of extracted.paths)
+                await checkPath(path);
+        },
+    };
+}

package/dist/plugin/index.d.ts

@@ -0,0 +1,36 @@
+import { type SortieDogsPluginOptions } from "./config.js";
+import { type ToolExecuteBeforeInput, type ToolExecuteBeforeOutput } from "./gate.js";
+import { type OpenCodeChatMessageHook } from "./model-routing-hook.js";
+export interface OpenCodePluginInput {
+    directory: string;
+    worktree?: string;
+    [key: string]: unknown;
+}
+export interface OpenCodeEvent {
+    type: string;
+    properties?: Record<string, unknown>;
+}
+export interface OpenCodeHooks {
+    event?: (input: {
+        event: OpenCodeEvent;
+    }) => Promise<void>;
+    "permission.ask"?: (input: {
+        permission: string;
+        patterns: string[];
+        sessionID?: string;
+    }, output: {
+        status: "ask" | "deny" | "allow";
+    }) => Promise<void>;
+    "tool.execute.before"?: (input: ToolExecuteBeforeInput, output: ToolExecuteBeforeOutput) => Promise<void>;
+    "chat.message"?: OpenCodeChatMessageHook;
+}
+export type OpenCodePlugin = (input: OpenCodePluginInput, options?: SortieDogsPluginOptions | Record<string, unknown>) => Promise<OpenCodeHooks>;
+export type HandoffDenialReason = "configuration-unavailable" | "path-invalid" | "input-unavailable" | "schema-invalid" | "contract-invalid";
+export declare class HandoffDeniedError extends Error {
+    readonly reason: HandoffDenialReason;
+    constructor(reason: HandoffDenialReason, path: string, options?: ErrorOptions);
+}
+/** Named OpenCode plugin export. Importing the package has no side effects; invoking it installs active gates. */
+export declare const SortieDogsPlugin: OpenCodePlugin;
+export type { SortieDogsPluginOptions } from "./config.js";
+export { InvalidModelTargetError, ModelRoutingDeniedError } from "./model-routing-hook.js";