abelworkflow 0.9.2 → 1.0.0-rc.1

package/skills/dev-browser/package.json

@@ -2,30 +2,34 @@
   "name": "dev-browser",
   "version": "0.0.1",
   "type": "module",
-  "imports": {
-    "@/*": "./src/*"
+  "engines": {
+    "node": ">=22"
+  },
+  "packageManager": "npm@10.9.2",
+  "exports": {
+    "./client": {
+      "types": "./dist/src/client.d.ts",
+      "import": "./dist/src/client.js"
+    }
   },
   "scripts": {
-    "start-server": "npx tsx scripts/start.ts standalone",
-    "start-extension": "npx tsx scripts/start.ts extension",
-    "dev": "npx tsx --watch src/index.ts",
+    "build": "tsc -p tsconfig.json",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "start": "node dist/scripts/start.js standalone",
+    "start-server": "node dist/scripts/start.js standalone",
+    "start-extension": "node dist/scripts/start.js extension",
     "test": "vitest run",
     "test:watch": "vitest"
   },
   "dependencies": {
-    "@hono/node-server": "^1.19.7",
-    "@hono/node-ws": "^1.2.0",
-    "express": "^4.21.0",
-    "hono": "^4.11.1",
+    "@hono/node-server": "^1.19.13",
+    "@hono/node-ws": "^1.3.1",
+    "hono": "^4.12.30",
     "playwright": "^1.49.0"
   },
   "devDependencies": {
-    "@types/express": "^5.0.0",
-    "tsx": "^4.21.0",
+    "@types/node": "^22.0.0",
     "typescript": "^5.0.0",
     "vitest": "^2.1.0"
-  },
-  "optionalDependencies": {
-    "@rollup/rollup-linux-x64-gnu": "^4.0.0"
   }
 }

package/skills/dev-browser/references/scraping.md

@@ -17,57 +17,106 @@ Scrolling is slow, unreliable, and wastes time. APIs return structured data with
 
 This prevents wasting time debugging a complex script when the issue is a simple path like `data.user.timeline` vs `data.user.result.timeline`.
 
-## Step-by-Step Workflow
-
-### 1. Capture Request Details
-
-First, intercept a request to understand URL structure and required headers:
-
-```typescript
-import { connect, waitForPageLoad } from "@/client.js";
-import * as fs from "node:fs";
-
-const client = await connect();
-const page = await client.page("site");
-
-let capturedRequest = null;
-page.on("request", (request) => {
-  const url = request.url();
-  // Look for API endpoints (adjust pattern for your target site)
-  if (url.includes("/api/") || url.includes("/graphql/")) {
-    capturedRequest = {
-      url: url,
-      headers: request.headers(),
-      method: request.method(),
-    };
-    fs.writeFileSync("tmp/request-details.json", JSON.stringify(capturedRequest, null, 2));
-    console.log("Captured request:", url.substring(0, 80) + "...");
+## External Script Setup
+
+Keep the installed skill directory read-only. Put scripts and temporary artifacts in the OS temporary directory or the task workspace, and remove them when the task finishes. External scripts receive the installed skill directory as their first argument and dynamically import the compiled client by file URL.
+
+Never persist complete authentication headers. Keep captured headers in memory, and write only redacted metadata or final non-sensitive results.
+
+```javascript
+import { mkdtemp, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { pathToFileURL } from "node:url";
+
+const skillDir = process.argv[2];
+if (!skillDir) throw new Error("Pass the installed dev-browser skill directory");
+const { connect, waitForPageLoad } = await import(
+  pathToFileURL(join(skillDir, "dist", "src", "client.js")).href
+);
+
+const workDir = await mkdtemp(join(tmpdir(), "dev-browser-scrape-"));
+let client;
+try {
+  client = await connect();
+  const page = await client.page("site");
+  let capturedRequest;
+
+  page.on("request", (request) => {
+    const url = request.url();
+    if (url.includes("/api/") || url.includes("/graphql/")) {
+      capturedRequest = {
+        url,
+        method: request.method(),
+        headers: request.headers(),
+      };
+    }
+  });
+
+  await page.goto("https://example.com/profile");
+  await waitForPageLoad(page);
+  await page.waitForTimeout(3000);
+
+  if (!capturedRequest) throw new Error("No matching API request captured");
+  const capturedUrl = new URL(capturedRequest.url);
+  console.log({
+    url: `${capturedUrl.origin}${capturedUrl.pathname}`,
+    method: capturedRequest.method,
+    headerNames: Object.keys(capturedRequest.headers),
+  });
+
+  const results = new Map();
+  let cursor;
+  do {
+    const params = { count: 20, ...(cursor ? { cursor } : {}) };
+    const url = new URL(capturedRequest.url);
+    url.searchParams.set("params", JSON.stringify(params));
+    const response = await page.evaluate(
+      async ({ url, headers }) => {
+        const result = await fetch(url, { headers });
+        return result.json();
+      },
+      { url: url.href, headers: capturedRequest.headers }
+    );
+
+    const entries = response?.data?.entries ?? [];
+    cursor = undefined;
+    for (const entry of entries) {
+      if (entry.type === "cursor-bottom") cursor = entry.value;
+      else if (entry.id) results.set(entry.id, entry);
+    }
+    await new Promise((resolve) => setTimeout(resolve, 500));
+  } while (cursor);
+
+  const resultPath = join(workDir, "results.json");
+  await writeFile(resultPath, JSON.stringify([...results.values()], null, 2));
+  console.log({ count: results.size, resultPath });
+} finally {
+  try {
+    await client?.disconnect();
+  } finally {
+    await rm(workDir, { recursive: true, force: true });
   }
-});
+}
+```
 
-await page.goto("https://example.com/profile");
-await waitForPageLoad(page);
-await page.waitForTimeout(3000);
+Run it with quoted paths on Linux, PowerShell, or Command Prompt:
 
-await client.disconnect();
+```text
+node "PATH_TO_SCRIPT.mjs" "PATH_TO_INSTALLED_DEV_BROWSER"
 ```
 
-### 2. Capture Response to Understand Schema
+If a result must survive the script, write the sanitized deliverable to the task workspace instead of `workDir`, then delete it at task completion unless the user asks to retain it.
 
-Save a raw response to inspect the data structure:
+## Step-by-Step Workflow
 
-```typescript
-page.on("response", async (response) => {
-  const url = response.url();
-  if (url.includes("UserTweets") || url.includes("/api/data")) {
-    const json = await response.json();
-    fs.writeFileSync("tmp/api-response.json", JSON.stringify(json, null, 2));
-    console.log("Captured response");
-  }
-});
-```
+### 1. Capture One Request
+
+Match a narrow API or GraphQL URL pattern. Keep the request URL and headers in memory. Log only the URL origin/path, method, and header names while confirming the endpoint; query parameters can contain credentials.
 
-Then analyze the structure to find:
+### 2. Inspect One Response
+
+Inspect the response in memory before building pagination. Find:
 
 - Where the data array lives (e.g., `data.user.result.timeline.instructions[].entries`)
 - Where pagination cursors are (e.g., `cursor-bottom` entries)
@@ -75,67 +124,7 @@ Then analyze the structure to find:
 
 ### 3. Replay API with Pagination
 
-Once you understand the schema, replay requests directly:
-
-```typescript
-import { connect } from "@/client.js";
-import * as fs from "node:fs";
-
-const client = await connect();
-const page = await client.page("site");
-
-const results = new Map(); // Use Map for deduplication
-const headers = JSON.parse(fs.readFileSync("tmp/request-details.json", "utf8")).headers;
-const baseUrl = "https://example.com/api/data";
-
-let cursor = null;
-let hasMore = true;
-
-while (hasMore) {
-  // Build URL with pagination cursor
-  const params = { count: 20 };
-  if (cursor) params.cursor = cursor;
-  const url = `${baseUrl}?params=${encodeURIComponent(JSON.stringify(params))}`;
-
-  // Execute fetch in browser context (has auth cookies/headers)
-  const response = await page.evaluate(
-    async ({ url, headers }) => {
-      const res = await fetch(url, { headers });
-      return res.json();
-    },
-    { url, headers }
-  );
-
-  // Extract data and cursor (adjust paths for your API)
-  const entries = response?.data?.entries || [];
-  for (const entry of entries) {
-    if (entry.type === "cursor-bottom") {
-      cursor = entry.value;
-    } else if (entry.id && !results.has(entry.id)) {
-      results.set(entry.id, {
-        id: entry.id,
-        text: entry.content,
-        timestamp: entry.created_at,
-      });
-    }
-  }
-
-  console.log(`Fetched page, total: ${results.size}`);
-
-  // Check stop conditions
-  if (!cursor || entries.length === 0) hasMore = false;
-
-  // Rate limiting - be respectful
-  await new Promise((r) => setTimeout(r, 500));
-}
-
-// Export results
-const data = Array.from(results.values());
-fs.writeFileSync("tmp/results.json", JSON.stringify(data, null, 2));
-console.log(`Saved ${data.length} items`);
-
-await client.disconnect();
-```
+Replay through `page.evaluate(fetch)` so the browser supplies its session cookies. Pass only the in-memory headers required by the endpoint, deduplicate with a `Map`, stop when the cursor or results end, and rate-limit requests.
 
 ## Key Patterns
 
@@ -149,7 +138,7 @@ await client.disconnect();
 
 ## Tips
 
-- **Extension mode**: `page.context().cookies()` doesn't work - capture auth headers from intercepted requests instead
+- **Extension mode**: `page.context().cookies()` doesn't work - keep intercepted auth headers in memory instead
 - **Rate limiting**: Add 500ms+ delays between requests to avoid blocks
 - **Stop conditions**: Check for empty results, missing cursor, or reaching a date/ID threshold
 - **GraphQL APIs**: URL params often include `variables` and `features` JSON objects - capture and reuse them

package/skills/grok-search/defaults.json

@@ -0,0 +1,3 @@
+{
+  "model": "grok-4.20-auto"
+}

package/skills/grok-search/gitignore.template

@@ -0,0 +1,4 @@
+GrokSearch_new/
+.env
+.venv/
+*__pycache__*

package/skills/grok-search/scripts/_dotenv.py

@@ -9,6 +9,7 @@ def load_dotenv() -> bool:
     if not env_path.exists():
         return False
     try:
+        seen_keys = set()
         with open(env_path, "r", encoding="utf-8") as f:
             for line in f:
                 line = line.strip()
@@ -21,7 +22,10 @@ def load_dotenv() -> bool:
                     value.startswith("'") and value.endswith("'")
                 ):
                     value = value[1:-1]
-                if key and not os.environ.get(key):
+                if not key or key in seen_keys:
+                    continue
+                seen_keys.add(key)
+                if not os.environ.get(key):
                     os.environ[key] = value
         return True
     except IOError:

package/skills/grok-search/scripts/groksearch_cli.py

@@ -15,6 +15,8 @@ from pathlib import Path
 from typing import Optional
 from urllib.parse import urlsplit, urlunsplit
 
+from _dotenv import load_dotenv
+
 try:
     import httpx
     from tenacity import AsyncRetrying, retry_if_exception, stop_after_attempt, wait_random_exponential
@@ -24,38 +26,6 @@ except ImportError:
     sys.exit(1)
 
 
-# ============================================================================
-# .env 文件支持
-# ============================================================================
-
-def load_dotenv() -> bool:
-    """从项目根目录的 .env 文件加载环境变量。"""
-    env_path = Path(__file__).parent.parent / ".env"
-    if env_path.exists():
-        try:
-            with open(env_path, 'r', encoding='utf-8') as f:
-                for line in f:
-                    line = line.strip()
-                    if not line or line.startswith('#'):
-                        continue
-                    if '=' in line:
-                        key, _, value = line.partition('=')
-                        key = key.strip()
-                        value = value.strip()
-                        # 如果存在引号则移除
-                        if (value.startswith('"') and value.endswith('"')) or \
-                           (value.startswith("'") and value.endswith("'")):
-                            value = value[1:-1]
-                        # 允许 .env 覆盖空字符串环境变量
-                        if key and not os.environ.get(key):
-                            os.environ[key] = value
-            return True
-        except IOError:
-            pass
-    return False
-
-
-# 模块导入时加载 .env
 load_dotenv()
 
 
@@ -63,9 +33,21 @@ load_dotenv()
 # 配置
 # ============================================================================
 
+def load_default_model() -> str:
+    defaults_path = Path(__file__).resolve().parent.parent / "defaults.json"
+    try:
+        defaults = json.loads(defaults_path.read_text(encoding="utf-8"))
+        model = defaults["model"]
+    except (OSError, json.JSONDecodeError, KeyError, TypeError) as error:
+        raise RuntimeError(f"无法读取 Grok 默认配置 {defaults_path}: {error}") from error
+    if not isinstance(model, str) or not model.strip():
+        raise RuntimeError(f"Grok 默认配置缺少有效 model: {defaults_path}")
+    return model
+
+
 class Config:
     _instance = None
-    _DEFAULT_MODEL = "grok-4.20-auto"
+    _DEFAULT_MODEL = load_default_model()
 
     def __new__(cls):
         if cls._instance is None:

package/skills/prompt-enhancer/TEMPLATE.md

@@ -84,8 +84,4 @@ Identify and fix the sorting bug in the codebase.
 5. Add or update tests to cover the bug scenario
 
 # Constraints
-- Maintain backward compatibility
-- Do not change the function signature unless necessary
-- Add inline comments explaining the fix
 ```
-

package/skills/prompt-enhancer/requirements.txt

@@ -1,2 +1 @@
-anthropic>=0.34,<1
 openai>=1.30,<2

package/skills/prompt-enhancer/scripts/_dotenv.py

@@ -9,6 +9,7 @@ def load_dotenv() -> bool:
     if not env_path.exists():
         return False
     try:
+        seen_keys = set()
         with open(env_path, "r", encoding="utf-8") as f:
             for line in f:
                 line = line.strip()
@@ -21,7 +22,10 @@ def load_dotenv() -> bool:
                     value.startswith("'") and value.endswith("'")
                 ):
                     value = value[1:-1]
-                if key and not os.environ.get(key):
+                if not key or key in seen_keys:
+                    continue
+                seen_keys.add(key)
+                if not os.environ.get(key):
                     os.environ[key] = value
         return True
     except IOError:

package/skills/prompt-enhancer/scripts/enhance.py

@@ -72,19 +72,7 @@ def resolve_prompt(args: argparse.Namespace) -> str:
     raise ValueError("Missing prompt. Pass --prompt \"...\" or a positional prompt.")
 
 
-def first_non_empty(*values: str) -> str:
-    for value in values:
-        stripped = value.strip()
-        if stripped:
-            return stripped
-    return ""
-
-
-def env_value(*names: str) -> str:
-    return first_non_empty(*(os.environ.get(name, "") for name in names))
-
-
-def resolve_config(args: argparse.Namespace) -> Tuple[str, str, str, str]:
+def resolve_config(args: argparse.Namespace) -> Tuple[str, str, str]:
     api_url = (args.api_url or os.environ.get("PE_API_URL", "")).strip()
     api_key = (args.api_key or os.environ.get("PE_API_KEY", "")).strip()
     model = (args.model or os.environ.get("PE_MODEL", "")).strip()
@@ -97,44 +85,12 @@ def resolve_config(args: argparse.Namespace) -> Tuple[str, str, str, str]:
     if not model:
         missing.append("model")
     if missing:
-        has_openai_compatible_transport = bool(api_url or api_key)
-        if has_openai_compatible_transport:
-            raise ValueError(
-                "Missing third-party OpenAI-compatible config: "
-                + ", ".join(missing)
-                + ". If these fields are unavailable, use the current agent directly."
-            )
-
-        legacy_anthropic_key = env_value("ANTHROPIC_API_KEY")
-        if legacy_anthropic_key:
-            return "anthropic", "", legacy_anthropic_key, first_non_empty(model, "claude-sonnet-4-20250514")
-
-        legacy_openai_key = env_value("OPENAI_API_KEY")
-        if legacy_openai_key:
-            return "openai", "", legacy_openai_key, first_non_empty(model, "gpt-4o")
-
         raise ValueError(
             "Missing third-party OpenAI-compatible config: "
             + ", ".join(missing)
             + ". If these fields are unavailable, use the current agent directly."
         )
-    return "openai-compatible", api_url, api_key, model
-
-
-def enhance_with_anthropic(prompt: str, api_key: str, model: str) -> str:
-    try:
-        import anthropic
-    except ImportError:
-        raise RuntimeError("Missing dependency: anthropic. Install dependencies for the configured provider.") from None
-
-    client = anthropic.Anthropic(api_key=api_key)
-    message = client.messages.create(
-        model=model,
-        max_tokens=2048,
-        system=SYSTEM_PROMPT,
-        messages=[{"role": "user", "content": prompt}],
-    )
-    return message.content[0].text
+    return api_url, api_key, model
 
 
 def _extract_response_text(response) -> str:
@@ -170,11 +126,8 @@ def main() -> None:
     try:
         args = parse_args()
         prompt = resolve_prompt(args)
-        provider, api_url, api_key, model = resolve_config(args)
-        if provider == "anthropic":
-            print(enhance_with_anthropic(prompt, api_key, model))
-        else:
-            print(enhance_with_openai(prompt, api_key, model, api_url))
+        api_url, api_key, model = resolve_config(args)
+        print(enhance_with_openai(prompt, api_key, model, api_url))
     except Exception as exc:
         if debug_enabled():
             print(f"Error: {exc}", file=sys.stderr)

package/skills/prompt-enhancer/scripts/prompt_enhancer_entry.py

@@ -99,10 +99,6 @@ def first_non_empty(*values: str) -> str:
     return ""
 
 
-def env_value(*names: str) -> str:
-    return first_non_empty(*(os.environ.get(name, "") for name in names))
-
-
 def argv_value(flag: str, argv: Optional[List[str]] = None) -> str:
     argv = sys.argv[1:] if argv is None else argv
     for index, token in enumerate(argv):
@@ -123,22 +119,11 @@ def resolved_provider(argv: Optional[List[str]] = None) -> Optional[str]:
 
     if api_url and api_key and model:
         return "openai"
-    if api_url or api_key:
-        return None
-    if env_value("ANTHROPIC_API_KEY"):
-        return "anthropic"
-    if env_value("OPENAI_API_KEY"):
-        return "openai"
     return None
 
 
 def required_modules() -> List[str]:
-    provider = resolved_provider()
-    if provider == "anthropic":
-        return ["anthropic"]
-    if provider == "openai":
-        return ["openai"]
-    return []
+    return ["openai"] if resolved_provider() == "openai" else []
 
 
 def install_targets(modules: List[str]) -> List[str]:

package/.skill-lock.json

@@ -1,29 +0,0 @@
-{
-  "version": 3,
-  "skills": {
-    "git-commit": {
-      "source": "github/awesome-copilot",
-      "sourceType": "github",
-      "sourceUrl": "https://github.com/github/awesome-copilot.git",
-      "skillPath": "skills/git-commit/SKILL.md",
-      "skillFolderHash": "883a6a7466f55a9cd9f22cf1cce2d9333fc9b998",
-      "installedAt": "2026-03-12T08:25:08.313Z",
-      "updatedAt": "2026-03-12T08:25:08.313Z"
-    }
-  },
-  "dismissed": {
-    "findSkillsPrompt": true
-  },
-  "lastSelectedAgents": [
-    "amp",
-    "cline",
-    "codex",
-    "cursor",
-    "gemini-cli",
-    "github-copilot",
-    "kimi-cli",
-    "opencode",
-    "claude-code",
-    "crush"
-  ]
-}