@oscharko-dev/keiko 0.1.5 → 0.1.7

package/dist/tools/browser/types.d.ts

@@ -1,48 +1 @@
-export interface NormalizedNavigateUrl {
-    readonly url: string;
-    readonly host: string;
-    readonly originOnly: string;
-    readonly port: number;
-}
-export interface BrowserViewportPx {
-    readonly width: number;
-    readonly height: number;
-}
-export type BrowserSessionStatus = "open" | "closed";
-export interface BrowserSessionMeta {
-    readonly sessionId: string;
-    readonly cdpPort: number;
-    readonly targetId: string;
-    readonly status: BrowserSessionStatus;
-    readonly createdAt: number;
-}
-export interface BrowserNavigateResult {
-    readonly originOnly: string;
-    readonly httpStatus: number | null;
-}
-export interface BrowserScreenshotPreview {
-    readonly seq: number;
-    readonly viewportPx: BrowserViewportPx;
-    readonly dataBase64: string;
-    readonly persisted: false;
-}
-export interface BrowserScreenshotPersisted {
-    readonly seq: number;
-    readonly viewportPx: BrowserViewportPx;
-    readonly persisted: true;
-    readonly path: string;
-    readonly sha256: string;
-    readonly bytes: number;
-}
-export type BrowserScreenshotResult = BrowserScreenshotPreview | BrowserScreenshotPersisted;
-export interface BrowserContentResult {
-    readonly seq: number;
-    readonly byteLength: number;
-    readonly redactedHtml: string;
-}
-export interface CdpReachability {
-    readonly reachable: boolean;
-    readonly userAgent: string | null;
-    readonly browserVersion: string | null;
-    readonly webSocketDebuggerUrl: string | null;
-}
+export type { BrowserContentResult, BrowserNavigateResult, BrowserScreenshotPersisted, BrowserScreenshotPreview, BrowserScreenshotResult, BrowserSessionMeta, BrowserSessionStatus, BrowserViewportPx, CdpReachability, NormalizedNavigateUrl, } from "@oscharko-dev/keiko-tools";

package/dist/tools/browser/types.js

@@ -1,2 +1,4 @@
-// Data shapes for the browser tool (ADR-0017). Pure types: no runtime imports.
+// Re-export shim: browser tool result/meta types live in @oscharko-dev/keiko-tools
+// (issue #162, ADR-0019). All existing import sites (`from "../tools/browser/types.js"`) keep
+// resolving unchanged via this barrel.
 export {};

package/dist/tools/browser/validators.d.ts

@@ -1,5 +1 @@
-import type { NormalizedNavigateUrl } from "./types.js";
-export declare function normalizeCdpPort(value: unknown): number;
-export declare function normalizeNavigateUrl(raw: unknown): NormalizedNavigateUrl;
-export declare function isLoopbackHost(host: string): boolean;
-export declare function isLoopbackUrl(raw: string): boolean;
+export { isLoopbackHost, isLoopbackUrl, normalizeCdpPort, normalizeNavigateUrl, } from "@oscharko-dev/keiko-tools";

package/dist/tools/browser/validators.js

@@ -1,97 +1,4 @@
-// ADR-0017 D2 — pure URL validation. NO filesystem, NO network. The localhost→127.0.0.1 rewrite
-// happens here so that downstream code never hands `localhost` to the OS resolver, eliminating the
-// /etc/hosts attack surface even if a downstream caller forgets the rule.
-import { BrowserToolError } from "./errors.js";
-const MIN_PORT = 1024;
-const MAX_PORT = 65535;
-const ALLOWED_SCHEMES = new Set(["http:", "https:"]);
-// Strict literal-host policy: IPv4-mapped IPv6 forms like `::ffff:127.0.0.1` are
-// REJECTED on purpose. ADR-0017 D2 normalises only `localhost`/`127.0.0.1`/`::1`.
-const LOOPBACK_HOSTS = new Set(["127.0.0.1", "::1"]);
-export function normalizeCdpPort(value) {
-    if (typeof value !== "number") {
-        throw new BrowserToolError("BAD_PORT", "CDP port must be a number.");
-    }
-    if (!Number.isInteger(value)) {
-        throw new BrowserToolError("BAD_PORT", "CDP port must be an integer.");
-    }
-    if (value < MIN_PORT || value > MAX_PORT) {
-        throw new BrowserToolError("BAD_PORT", `CDP port must be in the range ${String(MIN_PORT)}-${String(MAX_PORT)}.`);
-    }
-    return value;
-}
-// Parses the URL with the WHATWG parser, rejects non-http(s) schemes, rewrites `localhost` to its
-// literal IP before any further use, then enforces literal-IP loopback + bounded-port. Returns the
-// canonical {url, originOnly, host, port} struct the CDP layer consumes.
-export function normalizeNavigateUrl(raw) {
-    if (typeof raw !== "string" || raw.length === 0) {
-        throw new BrowserToolError("BAD_URL", "Navigate URL must be a non-empty string.");
-    }
-    const parsed = parseUrlOrThrow(raw);
-    if (!ALLOWED_SCHEMES.has(parsed.protocol)) {
-        throw new BrowserToolError("SCHEME_NOT_ALLOWED", "Navigate URL must use the http or https scheme.");
-    }
-    const rewritten = rewriteLocalhost(parsed);
-    const host = bareHost(rewritten);
-    if (!LOOPBACK_HOSTS.has(host)) {
-        throw new BrowserToolError("ORIGIN_NOT_ALLOWED", "Navigate URL host must be a loopback literal (127.0.0.1 or ::1).");
-    }
-    if (rewritten.port === "") {
-        throw new BrowserToolError("BAD_PORT", "Navigate URL must include an explicit port.");
-    }
-    const port = normalizeCdpPort(Number.parseInt(rewritten.port, 10));
-    return {
-        url: rewritten.toString(),
-        host,
-        originOnly: rewritten.origin,
-        port,
-    };
-}
-function parseUrlOrThrow(raw) {
-    try {
-        return new URL(raw);
-    }
-    catch {
-        throw new BrowserToolError("BAD_URL", "Navigate URL is not a valid URL.");
-    }
-}
-// `URL.hostname` returns `localhost` unchanged; we rewrite to 127.0.0.1 and rebuild the URL so the
-// canonical .url field handed to CDP never contains `localhost`.
-function rewriteLocalhost(parsed) {
-    if (parsed.hostname !== "localhost")
-        return parsed;
-    const clone = new URL(parsed.toString());
-    clone.hostname = "127.0.0.1";
-    return clone;
-}
-// URL.hostname returns `[::1]` for IPv6 input; strip brackets so the LOOPBACK_HOSTS set comparison
-// is performed against the bare literal `::1`.
-function bareHost(parsed) {
-    const h = parsed.hostname;
-    if (h.startsWith("[") && h.endsWith("]"))
-        return h.slice(1, -1);
-    return h;
-}
-// Narrow host-string check: takes a bare hostname (no scheme, no port, no brackets stripped)
-// and returns true if it is a loopback literal. Used by session.ts to validate the host
-// component of webSocketDebuggerUrl returned by /json/version (ADR-0017 D2 H1).
-export function isLoopbackHost(host) {
-    return LOOPBACK_HOSTS.has(host);
-}
-// Re-check after a navigation completes (ADR-0017 D2 layer 2). The CDP `frameNavigated` event
-// reports the effective URL; if it drifted to a non-loopback origin (server-side redirect), the
-// session manager must stop loading and refuse subsequent capture. Pure: takes the post-navigate
-// URL string and returns the typed result.
-export function isLoopbackUrl(raw) {
-    let parsed;
-    try {
-        parsed = new URL(raw);
-    }
-    catch {
-        return false;
-    }
-    if (!ALLOWED_SCHEMES.has(parsed.protocol))
-        return false;
-    const host = bareHost(parsed);
-    return LOOPBACK_HOSTS.has(host);
-}
+// Re-export shim: CDP validators (loopback / port / navigate URL) live in
+// @oscharko-dev/keiko-tools (issue #162, ADR-0019). All existing import sites
+// (`from "../tools/browser/validators.js"`) keep resolving unchanged via this barrel.
+export { isLoopbackHost, isLoopbackUrl, normalizeCdpPort, normalizeNavigateUrl, } from "@oscharko-dev/keiko-tools";

package/dist/tools/errors.d.ts

@@ -1,59 +1 @@
-import type { PatchConflict, PatchRejection } from "./types.js";
-export declare const TOOL_CODES: {
-    readonly ARGUMENT: "TOOL_ARGUMENT";
-    readonly UNKNOWN: "TOOL_UNKNOWN";
-    readonly COMMAND_DENIED: "TOOL_COMMAND_DENIED";
-    readonly COMMAND_TIMEOUT: "TOOL_COMMAND_TIMEOUT";
-    readonly COMMAND_CANCELLED: "TOOL_COMMAND_CANCELLED";
-    readonly OUTPUT_LIMIT: "TOOL_OUTPUT_LIMIT";
-    readonly PATCH_INVALID: "TOOL_PATCH_INVALID";
-    readonly PATCH_APPLY_DISABLED: "TOOL_PATCH_APPLY_DISABLED";
-    readonly PATCH_APPLY_FAILED: "TOOL_PATCH_APPLY_FAILED";
-};
-export type ToolCode = (typeof TOOL_CODES)[keyof typeof TOOL_CODES];
-export declare abstract class ToolError extends Error {
-    abstract readonly code: ToolCode;
-    constructor(message: string, secrets?: readonly string[]);
-}
-export declare class ToolArgumentError extends ToolError {
-    readonly code: "TOOL_ARGUMENT";
-    readonly toolName: string;
-    constructor(message: string, toolName: string, secrets?: readonly string[]);
-}
-export declare class UnknownToolError extends ToolError {
-    readonly code: "TOOL_UNKNOWN";
-    readonly toolName: string;
-    constructor(message: string, toolName: string, secrets?: readonly string[]);
-}
-export declare class CommandDeniedError extends ToolError {
-    readonly code: "TOOL_COMMAND_DENIED";
-    readonly executable: string;
-    constructor(message: string, executable: string, secrets?: readonly string[]);
-}
-export declare class CommandTimeoutError extends ToolError {
-    readonly code: "TOOL_COMMAND_TIMEOUT";
-    readonly timeoutMs: number;
-    constructor(message: string, timeoutMs: number, secrets?: readonly string[]);
-}
-export declare class CommandCancelledError extends ToolError {
-    readonly code: "TOOL_COMMAND_CANCELLED";
-}
-export declare class OutputLimitError extends ToolError {
-    readonly code: "TOOL_OUTPUT_LIMIT";
-    readonly limitBytes: number;
-    constructor(message: string, limitBytes: number, secrets?: readonly string[]);
-}
-export declare class PatchValidationError extends ToolError {
-    readonly code: "TOOL_PATCH_INVALID";
-    readonly reasons: readonly PatchRejection[];
-    readonly conflicts: readonly PatchConflict[];
-    constructor(message: string, reasons: readonly PatchRejection[], conflicts: readonly PatchConflict[], secrets?: readonly string[]);
-}
-export declare class PatchApplyDisabledError extends ToolError {
-    readonly code: "TOOL_PATCH_APPLY_DISABLED";
-}
-export declare class PatchApplyError extends ToolError {
-    readonly code: "TOOL_PATCH_APPLY_FAILED";
-    readonly path: string;
-    constructor(message: string, path: string, secrets?: readonly string[]);
-}
+export { CommandCancelledError, CommandDeniedError, CommandTimeoutError, OutputLimitError, PatchApplyDisabledError, PatchApplyError, PatchValidationError, TOOL_CODES, ToolArgumentError, ToolError, UnknownToolError, type ToolCode, } from "@oscharko-dev/keiko-tools";

package/dist/tools/errors.js

@@ -1,94 +1,4 @@
-// Tool error taxonomy, mirroring gateway/harness/workspace (ADR-0003/0004/0005/0006).
-// Errors carry a stable `code` discriminant; callers switch on `code`, never parse `message`.
-// Every message is redacted at construction so errors are always safe to log or surface.
-import { redact } from "../gateway/redaction.js";
-export const TOOL_CODES = {
-    ARGUMENT: "TOOL_ARGUMENT",
-    UNKNOWN: "TOOL_UNKNOWN",
-    COMMAND_DENIED: "TOOL_COMMAND_DENIED",
-    COMMAND_TIMEOUT: "TOOL_COMMAND_TIMEOUT",
-    COMMAND_CANCELLED: "TOOL_COMMAND_CANCELLED",
-    OUTPUT_LIMIT: "TOOL_OUTPUT_LIMIT",
-    PATCH_INVALID: "TOOL_PATCH_INVALID",
-    PATCH_APPLY_DISABLED: "TOOL_PATCH_APPLY_DISABLED",
-    PATCH_APPLY_FAILED: "TOOL_PATCH_APPLY_FAILED",
-};
-export class ToolError extends Error {
-    constructor(message, secrets = []) {
-        super(redact(message, secrets));
-        this.name = new.target.name;
-    }
-}
-// Malformed tool arguments (a required field missing or of the wrong type).
-export class ToolArgumentError extends ToolError {
-    code = TOOL_CODES.ARGUMENT;
-    toolName;
-    constructor(message, toolName, secrets = []) {
-        super(message, secrets);
-        this.toolName = toolName;
-    }
-}
-// No such tool in the host's dispatch map.
-export class UnknownToolError extends ToolError {
-    code = TOOL_CODES.UNKNOWN;
-    toolName;
-    constructor(message, toolName, secrets = []) {
-        super(message, secrets);
-        this.toolName = toolName;
-    }
-}
-// Executable or subcommand not on the allowlist (deny-by-default). Raised BEFORE any spawn.
-export class CommandDeniedError extends ToolError {
-    code = TOOL_CODES.COMMAND_DENIED;
-    executable;
-    constructor(message, executable, secrets = []) {
-        super(message, secrets);
-        this.executable = executable;
-    }
-}
-// The command exceeded its wall-time budget and was terminated.
-export class CommandTimeoutError extends ToolError {
-    code = TOOL_CODES.COMMAND_TIMEOUT;
-    timeoutMs;
-    constructor(message, timeoutMs, secrets = []) {
-        super(message, secrets);
-        this.timeoutMs = timeoutMs;
-    }
-}
-// Abort-driven cancellation of a command or a patch apply.
-export class CommandCancelledError extends ToolError {
-    code = TOOL_CODES.COMMAND_CANCELLED;
-}
-// A hard output-limit breach (used where truncate-and-flag is not acceptable, e.g. patch input).
-export class OutputLimitError extends ToolError {
-    code = TOOL_CODES.OUTPUT_LIMIT;
-    limitBytes;
-    constructor(message, limitBytes, secrets = []) {
-        super(message, secrets);
-        this.limitBytes = limitBytes;
-    }
-}
-// Patch validation failed; carries the structured rejection reasons. Nothing was written.
-export class PatchValidationError extends ToolError {
-    code = TOOL_CODES.PATCH_INVALID;
-    reasons;
-    conflicts;
-    constructor(message, reasons, conflicts, secrets = []) {
-        super(message, secrets);
-        this.reasons = reasons;
-        this.conflicts = conflicts;
-    }
-}
-// Fail-closed: apply requested while applyEnabled is false. Nothing was written.
-export class PatchApplyDisabledError extends ToolError {
-    code = TOOL_CODES.PATCH_APPLY_DISABLED;
-}
-// A write (or rollback) failed during the apply phase at the filesystem boundary.
-export class PatchApplyError extends ToolError {
-    code = TOOL_CODES.PATCH_APPLY_FAILED;
-    path;
-    constructor(message, path, secrets = []) {
-        super(message, secrets);
-        this.path = path;
-    }
-}
+// Re-export shim: tools error taxonomy lives in @oscharko-dev/keiko-tools (issue #162, ADR-0019),
+// which itself re-exports from @oscharko-dev/keiko-security. All existing import sites
+// (`from "../tools/errors.js"`) keep resolving unchanged via this barrel.
+export { CommandCancelledError, CommandDeniedError, CommandTimeoutError, OutputLimitError, PatchApplyDisabledError, PatchApplyError, PatchValidationError, TOOL_CODES, ToolArgumentError, ToolError, UnknownToolError, } from "@oscharko-dev/keiko-tools";

package/dist/tools/exec.d.ts

@@ -1,42 +1,2 @@
-import type { ChildProcess } from "node:child_process";
-import { type WorkspaceFs } from "../workspace/fs.js";
-import type { WorkspaceInfo } from "../workspace/types.js";
-import type { CommandResult, CommandRule, SandboxPolicy } from "./types.js";
-export interface SpawnOptions {
-    readonly cwd: string;
-    readonly env: Record<string, string>;
-    readonly shell: false;
-    readonly detached: boolean;
-}
-export type SpawnFn = (command: string, args: readonly string[], options: SpawnOptions) => ChildProcess;
-export interface ExecutableResolverDeps {
-    readonly workspace: WorkspaceInfo;
-    readonly processEnv: NodeJS.ProcessEnv;
-    readonly fs?: WorkspaceFs | undefined;
-}
-export type ExecutableResolver = (command: string, deps: ExecutableResolverDeps) => string;
-export declare const nodeSpawnFn: SpawnFn;
-export interface HomeProvider {
-    readonly make: () => string;
-    readonly cleanup: (dir: string) => void;
-}
-export declare const nodeHomeProvider: HomeProvider;
-export interface RunCommandDeps {
-    readonly workspace: WorkspaceInfo;
-    readonly policy: SandboxPolicy;
-    readonly commandRules: readonly CommandRule[];
-    readonly spawn: SpawnFn;
-    readonly resolveExecutable?: ExecutableResolver | undefined;
-    readonly processEnv: NodeJS.ProcessEnv;
-    readonly now: () => number;
-    readonly fs?: WorkspaceFs | undefined;
-    readonly home?: HomeProvider | undefined;
-}
-export interface RunCommandInput {
-    readonly command: string;
-    readonly args: readonly string[];
-    readonly cwd: string | undefined;
-    readonly timeoutMs: number | undefined;
-    readonly signal: AbortSignal;
-}
-export declare function runCommand(input: RunCommandInput, deps: RunCommandDeps): Promise<CommandResult>;
+export { nodeHomeProvider, nodeSpawnFn } from "@oscharko-dev/keiko-tools/internal/exec";
+export { runCommand, type ExecutableResolver, type ExecutableResolverDeps, type HomeProvider, type RunCommandDeps, type RunCommandInput, type SpawnFn, type SpawnOptions, } from "@oscharko-dev/keiko-tools";