@jshookmcp/jshook 0.2.6 → 0.2.7

package/dist/src/utils/outputPaths.d.ts

@@ -1,12 +0,0 @@
-export declare function getProjectRoot(): string;
-export declare function resolveOutputDirectory(inputDir: string | undefined, fallbackDir?: string): string;
-export declare function resolveScreenshotOutputPath(options: {
-    requestedPath?: string;
-    type?: 'png' | 'jpeg';
-    fallbackName?: string;
-    fallbackDir?: string;
-}): Promise<{
-    absolutePath: string;
-    displayPath: string;
-    pathRewritten: boolean;
-}>;

package/dist/src/utils/outputPaths.js

@@ -1,77 +0,0 @@
-import { mkdir } from 'node:fs/promises';
-import { basename, dirname, extname, isAbsolute, normalize, relative, resolve, sep, } from 'node:path';
-import { fileURLToPath } from 'node:url';
-const defaultProjectRoot = fileURLToPath(new URL('../..', import.meta.url));
-function resolveProjectRoot(env = process.env) {
-    const requestedRoot = env.MCP_PROJECT_ROOT?.trim();
-    if (!requestedRoot) {
-        return defaultProjectRoot;
-    }
-    return normalize(isAbsolute(requestedRoot) ? requestedRoot : resolve(defaultProjectRoot, requestedRoot));
-}
-function isInside(baseDir, targetPath) {
-    const rel = relative(baseDir, targetPath);
-    if (!rel || rel === '..' || rel.startsWith(`..${sep}`) || isAbsolute(rel)) {
-        return false;
-    }
-    return true;
-}
-function resolveWithinProject(inputPath, baseRoot = getProjectRoot()) {
-    const candidate = isAbsolute(inputPath) ? normalize(inputPath) : resolve(baseRoot, inputPath);
-    return isInside(baseRoot, candidate)
-        ? candidate
-        : resolve(baseRoot, 'screenshots', 'external', normalize(inputPath).split(/[\\/]/).pop() || 'output.bin');
-}
-function withDefaultExtension(filePath, extension) {
-    if (extname(filePath)) {
-        return filePath;
-    }
-    return `${filePath}.${extension.replace(/^\./, '')}`;
-}
-export function getProjectRoot() {
-    return resolveProjectRoot();
-}
-export function resolveOutputDirectory(inputDir, fallbackDir = 'screenshots') {
-    const projectRoot = getProjectRoot();
-    const requested = inputDir?.trim();
-    if (!requested) {
-        return resolve(projectRoot, fallbackDir);
-    }
-    const resolved = resolveWithinProject(requested, projectRoot);
-    if (isInside(projectRoot, resolved)) {
-        return resolved;
-    }
-    return resolve(projectRoot, fallbackDir);
-}
-export async function resolveScreenshotOutputPath(options) {
-    const projectRoot = getProjectRoot();
-    const extension = options.type === 'jpeg' ? 'jpg' : 'png';
-    const fallbackDir = options.fallbackDir || 'screenshots/manual';
-    const fallbackName = options.fallbackName || 'page';
-    const screenshotRoot = resolveOutputDirectory(process.env.MCP_SCREENSHOT_DIR, fallbackDir);
-    const requested = options.requestedPath?.trim();
-    let absolutePath;
-    let pathRewritten = false;
-    if (!requested) {
-        absolutePath = resolve(screenshotRoot, `${fallbackName}-${Date.now()}.${extension}`);
-        pathRewritten = true;
-    }
-    else {
-        const requestedWithExt = withDefaultExtension(requested, extension);
-        if (isAbsolute(requestedWithExt)) {
-            absolutePath = normalize(requestedWithExt);
-        }
-        else {
-            absolutePath = resolve(screenshotRoot, requestedWithExt);
-            if (!isInside(screenshotRoot, absolutePath)) {
-                absolutePath = resolve(screenshotRoot, basename(absolutePath));
-                pathRewritten = true;
-            }
-        }
-    }
-    await mkdir(dirname(absolutePath), { recursive: true });
-    const displayPath = isAbsolute(requested || '')
-        ? absolutePath.replace(/\\/g, '/')
-        : relative(projectRoot, absolutePath).replace(/\\/g, '/');
-    return { absolutePath, displayPath, pathRewritten };
-}

package/dist/src/utils/parallel.d.ts

@@ -1,39 +0,0 @@
-export interface ParallelOptions {
-    maxConcurrency?: number;
-    timeout?: number;
-    retryOnError?: boolean;
-    maxRetries?: number;
-}
-export interface TaskResult<T> {
-    success: boolean;
-    data?: T;
-    error?: Error;
-    duration: number;
-}
-export declare function parallelExecute<T, R>(items: T[], executor: (item: T, index: number) => Promise<R>, options?: ParallelOptions): Promise<TaskResult<R>[]>;
-export declare function batchProcess<T, R>(items: T[], executor: (batch: T[]) => Promise<R[]>, batchSize?: number): Promise<R[]>;
-export declare class TaskQueue<T, R> {
-    private queue;
-    private running;
-    private maxConcurrency;
-    private executor;
-    constructor(executor: (item: T) => Promise<R>, maxConcurrency?: number);
-    add(item: T): Promise<R>;
-    private process;
-    getStatus(): {
-        queueLength: number;
-        running: number;
-        maxConcurrency: number;
-    };
-    clear(): void;
-}
-export declare class RateLimiter {
-    private tokens;
-    private maxTokens;
-    private refillRate;
-    private lastRefill;
-    constructor(maxTokens: number, refillRate: number);
-    private refill;
-    acquire(tokens?: number): Promise<void>;
-    getTokens(): number;
-}

package/dist/src/utils/parallel.js

@@ -1,156 +0,0 @@
-import { logger } from './logger.js';
-import { PARALLEL_DEFAULT_CONCURRENCY, PARALLEL_DEFAULT_TIMEOUT_MS, PARALLEL_DEFAULT_MAX_RETRIES, PARALLEL_RETRY_BACKOFF_BASE_MS, } from '../constants.js';
-export async function parallelExecute(items, executor, options = {}) {
-    const { maxConcurrency = PARALLEL_DEFAULT_CONCURRENCY, timeout = PARALLEL_DEFAULT_TIMEOUT_MS, retryOnError = false, maxRetries = PARALLEL_DEFAULT_MAX_RETRIES, } = options;
-    const results = [];
-    const executing = new Set();
-    for (let i = 0; i < items.length; i++) {
-        const item = items[i];
-        if (item === undefined)
-            continue;
-        const task = (async () => {
-            const startTime = Date.now();
-            let lastError;
-            for (let attempt = 0; attempt <= (retryOnError ? maxRetries : 0); attempt++) {
-                try {
-                    const result = await new Promise((resolve, reject) => {
-                        const timer = setTimeout(() => reject(new Error('Task timeout')), timeout);
-                        executor(item, i).then((v) => {
-                            clearTimeout(timer);
-                            resolve(v);
-                        }, (e) => {
-                            clearTimeout(timer);
-                            reject(e);
-                        });
-                    });
-                    results[i] = {
-                        success: true,
-                        data: result,
-                        duration: Date.now() - startTime,
-                    };
-                    return;
-                }
-                catch (error) {
-                    lastError = error instanceof Error ? error : new Error(String(error));
-                    if (attempt < (retryOnError ? maxRetries : 0)) {
-                        logger.warn(`Task ${i} failed, retrying (${attempt + 1}/${maxRetries})...`);
-                        await new Promise((resolve) => setTimeout(resolve, PARALLEL_RETRY_BACKOFF_BASE_MS * (attempt + 1)));
-                    }
-                }
-            }
-            results[i] = {
-                success: false,
-                error: lastError,
-                duration: Date.now() - startTime,
-            };
-        })();
-        const wrappedTask = task.finally(() => {
-            executing.delete(wrappedTask);
-        });
-        executing.add(wrappedTask);
-        if (executing.size >= maxConcurrency) {
-            await Promise.race(executing);
-        }
-    }
-    await Promise.all(executing);
-    return results;
-}
-export async function batchProcess(items, executor, batchSize = 10) {
-    const results = [];
-    for (let i = 0; i < items.length; i += batchSize) {
-        const batch = items.slice(i, i + batchSize);
-        logger.debug(`Processing batch ${Math.floor(i / batchSize) + 1}/${Math.ceil(items.length / batchSize)}`);
-        try {
-            const batchResults = await executor(batch);
-            results.push(...batchResults);
-        }
-        catch (error) {
-            logger.error(`Batch processing failed at index ${i}`, error);
-            throw error;
-        }
-    }
-    return results;
-}
-export class TaskQueue {
-    queue = [];
-    running = 0;
-    maxConcurrency;
-    executor;
-    constructor(executor, maxConcurrency = 3) {
-        this.executor = executor;
-        this.maxConcurrency = maxConcurrency;
-    }
-    async add(item) {
-        return new Promise((resolve, reject) => {
-            this.queue.push({ item, resolve, reject });
-            void this.process();
-        });
-    }
-    async process() {
-        if (this.running >= this.maxConcurrency || this.queue.length === 0) {
-            return;
-        }
-        const task = this.queue.shift();
-        if (!task)
-            return;
-        this.running++;
-        try {
-            const result = await this.executor(task.item);
-            task.resolve(result);
-        }
-        catch (error) {
-            task.reject(error instanceof Error ? error : new Error(String(error)));
-        }
-        finally {
-            this.running--;
-            void this.process();
-        }
-    }
-    getStatus() {
-        return {
-            queueLength: this.queue.length,
-            running: this.running,
-            maxConcurrency: this.maxConcurrency,
-        };
-    }
-    clear() {
-        this.queue.forEach((task) => {
-            task.reject(new Error('Queue cleared'));
-        });
-        this.queue = [];
-    }
-}
-export class RateLimiter {
-    tokens;
-    maxTokens;
-    refillRate;
-    lastRefill;
-    constructor(maxTokens, refillRate) {
-        this.maxTokens = maxTokens;
-        this.tokens = maxTokens;
-        this.refillRate = refillRate;
-        this.lastRefill = Date.now();
-    }
-    refill() {
-        const now = Date.now();
-        const elapsed = (now - this.lastRefill) / 1000;
-        const tokensToAdd = elapsed * this.refillRate;
-        this.tokens = Math.min(this.maxTokens, this.tokens + tokensToAdd);
-        this.lastRefill = now;
-    }
-    async acquire(tokens = 1) {
-        while (true) {
-            this.refill();
-            if (this.tokens >= tokens) {
-                this.tokens -= tokens;
-                return;
-            }
-            const waitTime = ((tokens - this.tokens) / this.refillRate) * 1000;
-            await new Promise((resolve) => setTimeout(resolve, Math.min(waitTime, 1000)));
-        }
-    }
-    getTokens() {
-        this.refill();
-        return this.tokens;
-    }
-}

package/workflows/anti-bot-diagnoser/.jshook-install.json

@@ -1,14 +0,0 @@
-{
-  "version": 1,
-  "kind": "workflow",
-  "slug": "anti-bot-diagnoser",
-  "id": "workflow.anti-bot-diagnoser.v1",
-  "source": {
-    "type": "git",
-    "repo": "https://github.com/vmoranv/jshook_workflow_anti_bot_diagnoser",
-    "ref": "main",
-    "commit": "b7e270de2a0cbb90ed431bd9de4fcd101cc53439",
-    "subpath": ".",
-    "entry": "workflow.ts"
-  }
-}

package/workflows/anti-bot-diagnoser/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2026 vmoranv
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

package/workflows/anti-bot-diagnoser/README.md

@@ -1,105 +0,0 @@
-# jshook_workflow_template
-
-TypeScript-first template repository for building a reusable `jshook` workflow.
-
-This template focuses on one thing:
-
-- codify an existing built-in tool chain into a reusable workflow contract
-- keep TypeScript source in Git and generated JavaScript out of Git
-
-## Included in the template
-
-- `workflow.ts`: workflow source entrypoint
-- `docs/agent-recipes.md`: recipes for orchestration, parallel reads, and subagent-assisted analysis
-- `dist/workflow.js`: generated locally by `pnpm run build` and ignored by Git
-
-## What the MVP workflow demonstrates
-
-The sample workflow runs this shape:
-
-1. `network_enable`
-2. `page_navigate`
-3. parallel surface collection
-   - `page_get_local_storage`
-   - `page_get_cookies`
-   - `network_get_requests`
-   - `page_get_all_links`
-   - optional `console_get_logs`
-4. `network_extract_auth`
-5. `console_execute` summary output
-
-## Dependency model
-
-This template uses the published npm package:
-
-```json
-{
-  "@jshookmcp/extension-sdk": "^0.1.3"
-}
-```
-
-## Install and build
-
-```bash
-pnpm install
-pnpm run build
-pnpm run check
-```
-
-## Loading behavior
-
-`jshook` discovers both `workflow.ts` and `dist/workflow.js`, but when both exist it prefers the generated JavaScript entry.
-
-Recommended workflow:
-
-1. edit `workflow.ts`
-2. run `pnpm run build`
-3. let `jshook` load `dist/workflow.js`
-
-Do **not** commit `dist/`.
-
-## Load the workflow into jshook
-
-Set:
-
-```bash
-MCP_WORKFLOW_ROOTS=<path-to-cloned-jshook_workflow_template>
-```
-
-Then run inside `jshook`:
-
-1. `extensions_reload`
-2. `extensions_list`
-3. `list_extension_workflows`
-4. `run_extension_workflow`
-
-## Configuration prefix
-
-The template uses:
-
-```text
-workflows.templateCapture.*
-```
-
-Rename that prefix early when adapting the template for real use.
-
-## Git hygiene
-
-Keep this repo focused on source and docs.
-Do not commit:
-
-- `dist/`
-- `node_modules/`
-- `.env`
-- runtime artifacts
-- screenshots
-- local sessions
-- host-specific temp output
-
-## What to change first
-
-1. replace `workflowId` and `displayName`
-2. rename the config prefix
-3. keep state-mutating steps serialized
-4. keep read-only collection steps parallel where safe
-5. validate the workflow through `extensions_reload` and `list_extension_workflows`

package/workflows/anti-bot-diagnoser/docs/agent-recipes.md

@@ -1,44 +0,0 @@
-# Agent Recipes for `jshook_workflow_template`
-
-## Core rule
-
-- parallelize reads, not shared page state mutations
-- let the main agent keep the active browser session
-- use subagents for sidecar analysis and report drafting
-
-## Recipe 1: run workflow, then delegate analysis
-
-Recommended split:
-
-- main agent
-  - `run_extension_workflow`
-  - optional `network_get_response_body`
-- subagent
-  - classify endpoints
-  - summarize auth and session artifacts
-  - draft report output
-
-## Recipe 2: main agent navigates, subagent reviews outputs
-
-Recommended split:
-
-- main agent
-  - `page_navigate`
-  - page actions
-  - `network_get_requests`
-- subagent
-  - endpoint matrix
-  - auth header and signature review
-  - next-step probing suggestions
-
-## Recipe 3: when to use parallel tool calls
-
-Good read-only candidates:
-
-- `extensions_list`
-- `search_tools`
-- `page_get_local_storage`
-- `page_get_cookies`
-- `console_get_logs`
-
-Avoid parallelizing any action that changes the current page state.

package/workflows/anti-bot-diagnoser/meta.yaml

@@ -1,6 +0,0 @@
-name: anti-bot-diagnoser
-description: JSHook workflow for anti-bot-diagnoser
-author: vmoranv
-tags:
-  - workflow
-  - anti-bot-diagnoser

package/workflows/anti-bot-diagnoser/package.json

@@ -1,22 +0,0 @@
-{
-  "name": "jshook-workflow-template",
-  "private": true,
-  "version": "0.1.0",
-  "description": "Standalone template repository for building jshook workflows.",
-  "type": "module",
-  "packageManager": "pnpm@10.28.2",
-  "scripts": {
-    "build": "tsc -p tsconfig.json",
-    "check": "tsc -p tsconfig.json --noEmit"
-  },
-  "dependencies": {
-    "@jshookmcp/extension-sdk": "^0.3.0"
-  },
-  "devDependencies": {
-    "@types/node": "^25.3.0",
-    "typescript": "^5.9.3"
-  },
-  "engines": {
-    "node": ">=20.0.0"
-  }
-}

package/workflows/anti-bot-diagnoser/tsconfig.json

@@ -1,15 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2022",
-    "module": "NodeNext",
-    "moduleResolution": "NodeNext",
-    "noEmit": false,
-    "outDir": "dist",
-    "rootDir": ".",
-    "strict": true,
-    "skipLibCheck": true,
-    "types": ["node"]
-  },
-  "include": ["workflow.ts"],
-  "exclude": ["dist", "node_modules"]
-}