abelworkflow 0.9.2 → 1.0.0

package/lib/tools/cli-installer.mjs

@@ -0,0 +1,277 @@
+import { spawn, spawnSync } from "node:child_process";
+import { join } from "node:path";
+import * as p from "@clack/prompts";
+import c from "picocolors";
+import { defaultPaths, getPlatform, isWindows } from "../paths.mjs";
+
+const { homeDir: home } = defaultPaths;
+
+function getRunCommandSpawnOptions(platform = getPlatform()) {
+  return { stdio: "inherit", shell: platform === "win32" };
+}
+
+function getCommandPath(command) {
+  const checker = isWindows() ? "where" : "which";
+  const result = spawnSync(checker, [command], { encoding: "utf8" });
+  if (result.status !== 0) {
+    return undefined;
+  }
+  return result.stdout
+    .split(/\r?\n/u)
+    .map((line) => line.trim())
+    .find(Boolean);
+}
+
+function commandExists(command) {
+  return Boolean(getCommandPath(command));
+}
+
+function readCommandOutput(command, args) {
+  const result = spawnSync(command, args, {
+    encoding: "utf8",
+    shell: isWindows(),
+    stdio: ["ignore", "pipe", "ignore"]
+  });
+  if (result.status !== 0) {
+    return undefined;
+  }
+  const outputValue = result.stdout.trim();
+  return outputValue || undefined;
+}
+
+async function runCommand(command, args) {
+  await new Promise((resolvePromise, rejectPromise) => {
+    const child = spawn(command, args, getRunCommandSpawnOptions(getPlatform()));
+    child.on("error", rejectPromise);
+    child.on("close", (code) => {
+      if (code === 0) {
+        resolvePromise();
+        return;
+      }
+      rejectPromise(new Error(`${command} ${args.join(" ")} exited with code ${code}`));
+    });
+  });
+}
+
+function normalizeInstallPath(value) {
+  if (!value) {
+    return "";
+  }
+  return value.replace(/\\/gu, "/").replace(/\/+$/u, "").toLowerCase();
+}
+
+function installPathIsWithin(path, parentPath) {
+  const normalizedPath = normalizeInstallPath(path);
+  const normalizedParent = normalizeInstallPath(parentPath);
+  return Boolean(normalizedPath && normalizedParent)
+    && (normalizedPath === normalizedParent || normalizedPath.startsWith(`${normalizedParent}/`));
+}
+
+function getNpmGlobalBinDirs(npmGlobalPrefix, platform = getPlatform()) {
+  if (!npmGlobalPrefix) {
+    return [];
+  }
+  return platform === "win32" ? [npmGlobalPrefix] : [join(npmGlobalPrefix, "bin")];
+}
+
+function inferPackageManagerFromCommandPath(commandPath, {
+  bunGlobalBinDir,
+  npmGlobalPrefix,
+  platform = getPlatform()
+} = {}) {
+  if (installPathIsWithin(commandPath, bunGlobalBinDir)) {
+    return "bun";
+  }
+  if (getNpmGlobalBinDirs(npmGlobalPrefix, platform)
+    .some((binDir) => installPathIsWithin(commandPath, binDir))) {
+    return "npm";
+  }
+  return null;
+}
+
+function chooseCliInstallPackageManager({
+  commandPath,
+  availablePackageManagers = [],
+  bunGlobalBinDir,
+  npmGlobalPrefix,
+  platform = getPlatform(),
+  nodeAvailable = true,
+  supportedPackageManagers = ["bun", "npm"]
+} = {}) {
+  const supported = new Set(supportedPackageManagers);
+  const available = new Set(availablePackageManagers.filter((packageManager) => {
+    if (!supported.has(packageManager)) {
+      return false;
+    }
+    return packageManager !== "bun" || nodeAvailable;
+  }));
+  const bunBlockedByMissingNode = !nodeAvailable
+    && supported.has("bun")
+    && availablePackageManagers.includes("bun");
+  const existingPackageManager = inferPackageManagerFromCommandPath(commandPath, {
+    bunGlobalBinDir,
+    npmGlobalPrefix,
+    platform
+  });
+
+  if (existingPackageManager && available.has(existingPackageManager)) {
+    return { packageManager: existingPackageManager, source: "existing" };
+  }
+  for (const packageManager of ["bun", "npm"]) {
+    if (available.has(packageManager)) {
+      return { packageManager, source: "available" };
+    }
+  }
+  return {
+    packageManager: null,
+    source: bunBlockedByMissingNode ? "missing-node" : (availablePackageManagers.length > 0 ? "unsupported" : "missing")
+  };
+}
+
+function buildCliToolInstallCommand(packageManager, { packageName, skipScripts = false }) {
+  if (packageManager === "npm") {
+    return {
+      command: "npm",
+      args: [
+        "install",
+        "-g",
+        ...(skipScripts ? ["--ignore-scripts"] : []),
+        packageName,
+        "--force"
+      ]
+    };
+  }
+  if (packageManager === "bun") {
+    return {
+      command: "bun",
+      args: [
+        "install",
+        "-g",
+        ...(skipScripts ? ["--ignore-scripts"] : []),
+        packageName
+      ]
+    };
+  }
+  throw new Error(`Unsupported package manager: ${packageManager}`);
+}
+
+function getPackageManagerInstallHelp(platform = getPlatform()) {
+  const platformLabel = {
+    darwin: "macOS",
+    win32: "Windows",
+    linux: "Linux"
+  }[platform] || platform;
+  return {
+    platformLabel,
+    mainlandUrl: "https://npmmirror.com/mirrors/node/",
+    officialUrl: "https://nodejs.org/en/download/"
+  };
+}
+
+function getAvailablePackageManagers() {
+  return ["bun", "npm"].filter((packageManager) => commandExists(packageManager));
+}
+
+function getBunGlobalBinDir(availablePackageManagers = getAvailablePackageManagers()) {
+  if (!availablePackageManagers.includes("bun")) {
+    return undefined;
+  }
+  return readCommandOutput("bun", ["pm", "bin", "-g"]) || join(home, ".bun", "bin");
+}
+
+function getNpmGlobalPrefix(availablePackageManagers = getAvailablePackageManagers()) {
+  if (!availablePackageManagers.includes("npm")) {
+    return undefined;
+  }
+  return readCommandOutput("npm", ["prefix", "-g"]);
+}
+
+async function installCliTool(tool, { confirmOrCancel }) {
+  const toolConfig = {
+    claude: {
+      label: "Claude Code",
+      command: "claude",
+      packageName: "@anthropic-ai/claude-code",
+      supportedPackageManagers: ["npm"],
+      installRequirement: "Claude Code 安装需要执行 postinstall；Bun 默认会阻止该脚本，因此需使用 npm。"
+    },
+    codex: {
+      label: "Codex",
+      command: "codex",
+      packageName: "@openai/codex"
+    },
+    pi: {
+      label: "Pi",
+      command: "pi",
+      packageName: "@earendil-works/pi-coding-agent",
+      skipScripts: true
+    }
+  }[tool];
+
+  if (!toolConfig) {
+    throw new Error(`Unsupported tool: ${tool}`);
+  }
+
+  const commandPath = getCommandPath(toolConfig.command);
+  const installed = Boolean(commandPath);
+  const availablePackageManagers = getAvailablePackageManagers();
+  const packageManagerChoice = chooseCliInstallPackageManager({
+    commandPath,
+    availablePackageManagers,
+    bunGlobalBinDir: getBunGlobalBinDir(availablePackageManagers),
+    npmGlobalPrefix: getNpmGlobalPrefix(availablePackageManagers),
+    platform: getPlatform(),
+    nodeAvailable: commandExists("node"),
+    supportedPackageManagers: toolConfig.supportedPackageManagers
+  });
+
+  if (!packageManagerChoice.packageManager) {
+    const help = getPackageManagerInstallHelp();
+    p.log.warn(`未检测到可用于安装 ${toolConfig.label} 的包管理器。`);
+    if (packageManagerChoice.source === "missing-node") {
+      p.log.message(`${toolConfig.label} 是 Node CLI；使用 Bun 安装前也需要先安装 Node.js。`);
+    }
+    if (toolConfig.installRequirement) {
+      p.log.message(toolConfig.installRequirement);
+    }
+    p.log.message(`${help.platformLabel} 可先安装 Node.js/npm，再重新运行安装。`);
+    p.log.message(`中国大陆镜像: ${help.mainlandUrl}`);
+    p.log.message(`官方下载页: ${help.officialUrl}`);
+    return;
+  }
+
+  if (installed) {
+    const managerMessage = packageManagerChoice.source === "existing"
+      ? `检测到原安装方式为 ${packageManagerChoice.packageManager}`
+      : `未识别原安装方式，将使用 ${packageManagerChoice.packageManager}`;
+    const shouldUpdate = await confirmOrCancel({
+      message: `${toolConfig.label} 已检测到（${managerMessage}），是否继续安装/更新？`,
+      initialValue: false
+    });
+    if (!shouldUpdate) {
+      p.log.message(`跳过 ${toolConfig.label} 安装。`);
+      return;
+    }
+  }
+
+  const installCommand = buildCliToolInstallCommand(packageManagerChoice.packageManager, toolConfig);
+  const s = p.spinner();
+  s.start(`正在使用 ${packageManagerChoice.packageManager} 安装 ${toolConfig.label}...`);
+  try {
+    await runCommand(installCommand.command, installCommand.args);
+    s.stop(`${toolConfig.label} 安装完成`);
+  } catch (e) {
+    s.cancel(c.red(`${toolConfig.label} 安装失败: ${e.message}`));
+    throw e;
+  }
+}
+
+export {
+  buildCliToolInstallCommand,
+  chooseCliInstallPackageManager,
+  getPackageManagerInstallHelp,
+  getRunCommandSpawnOptions,
+  inferPackageManagerFromCommandPath,
+  installCliTool,
+  commandExists
+};

package/package.json

@@ -1,11 +1,20 @@
 {
   "name": "abelworkflow",
-  "version": "0.9.2",
+  "version": "1.0.0",
   "description": "Install AbelWorkflow into ~/.agents and create Claude/Codex symlinks.",
   "type": "module",
   "scripts": {
-    "test": "node --test test/runtime-doc-contracts.test.mjs test/cli-contracts.test.mjs test/codex-config.test.mjs test/pi-auth-precedence.test.mjs test/pi-auth-write.test.mjs test/pi-provider-tls.test.mjs",
-    "test:contracts": "node --test test/runtime-doc-contracts.test.mjs test/cli-contracts.test.mjs"
+    "test": "npm run test:node",
+    "test:node": "node --test test/*.test.mjs",
+    "test:python": "python -m unittest discover -s test",
+    "test:dev-browser": "npm test --prefix skills/dev-browser",
+    "test:contracts": "node --test test/runtime-doc-contracts.test.mjs test/cli-args.test.mjs",
+    "typecheck": "npm run typecheck --prefix skills/dev-browser",
+    "build": "npm run build --prefix skills/dev-browser",
+    "prepack": "npm run build",
+    "check:docs": "node --test test/docs-contracts.test.mjs test/runtime-doc-contracts.test.mjs",
+    "check:package": "node --test test/package-contents.test.mjs",
+    "check": "npm run build && npm run test:node && npm run test:python && npm run test:dev-browser && npm run typecheck && npm run check:docs && npm run check:package"
   },
   "bin": {
     "abelworkflow": "bin/abelworkflow.mjs"
@@ -13,21 +22,39 @@
   "files": [
     "bin",
     "lib",
-    "AGENTS.md",
     "README.md",
-    "commands",
-    "skills",
     "extensions",
-    ".skill-lock.json",
-    ".gitignore"
+    "skills/context7-auto-research/.env.example",
+    "skills/context7-auto-research/SKILL.md",
+    "skills/context7-auto-research/context7-api.cjs",
+    "skills/dev-browser/SKILL.md",
+    "skills/dev-browser/dist",
+    "skills/dev-browser/package-lock.json",
+    "skills/dev-browser/package.json",
+    "skills/dev-browser/references",
+    "skills/git-commit/SKILL.md",
+    "skills/grok-search/.env.example",
+    "skills/grok-search/SKILL.md",
+    "skills/grok-search/defaults.json",
+    "skills/grok-search/gitignore.template",
+    "skills/grok-search/requirements.txt",
+    "skills/grok-search/scripts/_dotenv.py",
+    "skills/grok-search/scripts/groksearch_cli.py",
+    "skills/grok-search/scripts/groksearch_entry.py",
+    "skills/prompt-enhancer/SKILL.md",
+    "skills/prompt-enhancer/TEMPLATE.md",
+    "skills/time/SKILL.md",
+    "skills/time/scripts/time_cli.py"
   ],
   "engines": {
-    "node": ">=18"
+    "node": ">=22"
   },
+  "packageManager": "npm@10.9.2",
   "license": "MIT",
   "dependencies": {
     "@clack/prompts": "^1.2.0",
     "picocolors": "^1.1.1",
-    "proper-lockfile": "4.1.2"
+    "proper-lockfile": "4.1.2",
+    "smol-toml": "1.7.0"
   }
 }

package/skills/context7-auto-research/SKILL.md

@@ -30,13 +30,13 @@ Common cues:
 
 ## Workflow
 
-1. Run from this skill directory and use `./context7-api.js`.
+1. Run from this skill directory and use `./context7-api.cjs`.
 2. Search with the full user query:
 
 ```bash
 cd skills/context7-auto-research
-node ./context7-api.js --help
-node ./context7-api.js search '<library-name>' - <<'__C7_QUERY__'
+node ./context7-api.cjs --help
+node ./context7-api.cjs search '<library-name>' - <<'__C7_QUERY__'
 <full user query>
 __C7_QUERY__
 ```
@@ -50,7 +50,7 @@ __C7_QUERY__
 4. Fetch focused documentation:
 
 ```bash
-node ./context7-api.js context '<library-id>' - <<'__C7_QUERY__'
+node ./context7-api.cjs context '<library-id>' - <<'__C7_QUERY__'
 <feature name or focused question>
 __C7_QUERY__
 ```
@@ -72,7 +72,7 @@ __C7_QUERY__
 
 - Preferred: `CONTEXT7_API_KEY` environment variable
 - Also supported: `<skill-dir>/.env`
-- CLI help: `node ./context7-api.js --help`
+- CLI help: `node ./context7-api.cjs --help`
 
 ## Notes
 

package/skills/context7-auto-research/{context7-api.js → context7-api.cjs}

@@ -44,12 +44,12 @@ function printErrorResult(commandName, error, exitCode = 1) {
 
 function printUsage() {
   console.error(`Usage:
-  context7-api.js search <libraryName> <query|->
-  context7-api.js context <libraryId> <query|->
+  context7-api.cjs search <libraryName> <query|->
+  context7-api.cjs context <libraryId> <query|->
 
 Examples:
-  node context7-api.js search react "useEffect cleanup"
-  node context7-api.js context /facebook/react -
+  node context7-api.cjs search react "useEffect cleanup"
+  node context7-api.cjs context /facebook/react -
 
 Config:
   CONTEXT7_API_KEY from environment, or .env in the script directory`);
@@ -83,10 +83,7 @@ function loadApiKey() {
     if (key !== 'CONTEXT7_API_KEY') {
       continue;
     }
-    const value = trimmed.slice(separatorIndex + 1).trim();
-    if (value) {
-      return value.replace(/^["']|["']$/g, '');
-    }
+    return trimmed.slice(separatorIndex + 1).trim().replace(/^["']|["']$/g, '');
   }
 
   return null;

package/skills/dev-browser/SKILL.md

@@ -1,11 +1,11 @@
 ---
 name: dev-browser
-description: Browser automation with persistent page state. Use when users ask to navigate websites, fill forms, take screenshots, extract web data, test web apps, or automate browser workflows. Trigger phrases include "go to [url]", "click on", "fill out the form", "take a screenshot", "scrape", "automate", "test the website", "log into", or any browser interaction request.
+description: Browser automation with page state shared while the server process runs. Use when users ask to navigate websites, fill forms, take screenshots, extract web data, test web apps, or automate browser workflows. Trigger phrases include "go to [url]", "click on", "fill out the form", "take a screenshot", "scrape", "automate", "test the website", "log into", or any browser interaction request.
 ---
 
 # Dev Browser Skill
 
-Browser automation that maintains page state across script executions. Write small, focused scripts to accomplish tasks incrementally. Once you've proven out part of a workflow and there is repeated work to be done, you can write a script to do the repeated work in a single execution.
+Browser automation that maintains page state across script executions while the server process runs. Write small, focused scripts to accomplish tasks incrementally.
 
 ## Choosing Your Approach
 
@@ -22,13 +22,13 @@ Two supported startup modes are available on **Linux** and **native Windows**. R
 Launches a new Chromium browser for fresh automation sessions.
 
 ```text
-npx tsx scripts/start.ts standalone
+node dist/scripts/start.js standalone
 ```
 
 Add `--headless` if needed:
 
 ```text
-npx tsx scripts/start.ts standalone --headless
+node dist/scripts/start.js standalone --headless
 ```
 
 Wait for the stable readiness line `Ready` before running scripts.
@@ -43,7 +43,7 @@ Connects to the user's existing Chrome browser. Use this when:
 Start the relay server with:
 
 ```text
-npx tsx scripts/start.ts extension
+node dist/scripts/start.js extension
 ```
 
 Wait for `Waiting for extension to connect...`. Once the browser extension attaches, the relay logs `Extension connected`.
@@ -54,25 +54,32 @@ If the extension hasn't connected yet, tell the user to launch and activate it.
 
 | Mode | Linux | Native Windows | Readiness signal | Notes |
 |------|-------|----------------|------------------|-------|
-| standalone mode | Supported | Supported | `Ready` | Launches a managed Chromium profile under `profiles/` |
+| standalone mode | Supported | Supported | `Ready` | Uses a process-owned temporary Chromium profile and cleans it on exit |
 | extension mode | Supported | Supported | `Waiting for extension to connect...` then `Extension connected` | Requires the external browser extension to attach |
 
 ## Verification Checklist
 
-- Start `standalone mode` with `npx tsx scripts/start.ts standalone`
+- Start `standalone mode` with `node dist/scripts/start.js standalone`
 - Observe the readiness line `Ready`
 - Connect with `connect()` and create a named page
-- Start `extension mode` with `npx tsx scripts/start.ts extension`
+- Start `extension mode` with `node dist/scripts/start.js extension`
 - Observe `Waiting for extension to connect...`
 - Attach the browser extension and confirm `Extension connected`
 
 ## Known Differences
 
-- `standalone mode` launches and owns its own Chromium profile under this skill directory.
+- `standalone mode` owns a temporary Chromium profile only for the server process lifetime and cleans it on exit.
 - `extension mode` depends on the external browser extension and the user's existing Chrome session.
 - In `extension mode`, relay readiness means the server is waiting for the extension; it does not imply browser control is available until `Extension connected` appears.
 - `standalone mode` is the default path for deterministic local automation; `extension mode` is for working inside an already-authenticated browser.
 
+## Relay Origin Boundary
+
+- State-changing `/pages` requests accept only originless JSON clients; browser-origin and non-JSON mutations are rejected before backend calls.
+- `/cdp` accepts only originless WebSocket clients, which is the normal behavior of the Node client. Browser pages always send an `Origin` and are rejected.
+- `/extension` accepts originless protocol clients and valid `chrome-extension://` origins. HTTP(S), `null`, malformed, and other origins are rejected.
+- Rejected sockets close with WebSocket policy code `1008` before they can own a client ID, replace the extension, or route buffered messages.
+
 ## Non-goal Environments
 
 - `WSL` and `Git Bash` are not part of the supported Windows path for this skill.
@@ -81,37 +88,45 @@ If the extension hasn't connected yet, tell the user to launch and activate it.
 
 ## Writing Scripts
 
-Use small TypeScript files under `tmp/` instead of shell heredocs. Run them from the same `dev-browser` skill directory so the `@/` import alias resolves correctly.
+Treat the installed `dev-browser` skill directory as read-only. Store scripts and artifacts in the OS temporary directory or task workspace, never inside the skill directory, and delete files you created when the task ends.
 
-Example script (`tmp/example.ts`):
+External scripts cannot use package self-resolution, so pass the installed skill directory as the first argument and import its compiled client by file URL. Example:
 
-```typescript
-import { connect, waitForPageLoad } from "@/client.js";
+```javascript
+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 client = await connect();
 const page = await client.page("example", { viewport: { width: 1920, height: 1080 } });
 
 await page.goto("https://example.com");
 await waitForPageLoad(page);
+const screenshotPath = join(tmpdir(), "dev-browser-screenshot.png");
+await page.screenshot({ path: screenshotPath });
 
-console.log({ title: await page.title(), url: page.url() });
+console.log({ title: await page.title(), url: page.url(), screenshotPath });
 await client.disconnect();
 ```
 
-Run it with:
+This invocation works in Linux shells, PowerShell, and Command Prompt when the two paths are quoted:
 
 ```text
-npx tsx tmp/example.ts
+node "PATH_TO_SCRIPT.mjs" "PATH_TO_INSTALLED_DEV_BROWSER"
 ```
 
-**Write to `tmp/` files only when** the script needs reuse, is complex, or user explicitly requests it.
-
 ### Key Principles
 
 1. **Small scripts**: Each script does ONE thing (navigate, click, fill, check)
 2. **Evaluate state**: Log/return state at the end to decide next steps
 3. **Descriptive page names**: Use `"checkout"`, `"login"`, not `"main"`
-4. **Disconnect to exit**: `await client.disconnect()` - pages persist on server
+4. **Disconnect to exit**: `await client.disconnect()` - pages persist while the server process runs
 5. **Plain JS in evaluate**: `page.evaluate()` runs in browser - no TypeScript syntax
 
 ## Workflow Loop
@@ -156,7 +171,7 @@ const pageWithSize = await client.page("name", { viewport: { width: 1920, height
 
 const pages = await client.list(); // List all page names
 await client.close("name"); // Close a page
-await client.disconnect(); // Disconnect (pages persist)
+await client.disconnect(); // Disconnect (pages persist while the server runs)
 
 // ARIA Snapshot methods
 const snapshot = await client.getAISnapshot("name"); // Get accessibility tree
@@ -167,9 +182,7 @@ The `page` object is a standard Playwright Page.
 
 ## Waiting
 
-```typescript
-import { waitForPageLoad } from "@/client.js";
-
+```javascript
 await waitForPageLoad(page); // After navigation
 await page.waitForSelector(".results"); // For specific elements
 await page.waitForURL("**/success"); // For specific URL
@@ -179,11 +192,18 @@ await page.waitForURL("**/success"); // For specific URL
 
 ### Screenshots
 
-```typescript
-await page.screenshot({ path: "tmp/screenshot.png" });
-await page.screenshot({ path: "tmp/full.png", fullPage: true });
+```javascript
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+const screenshotPath = join(tmpdir(), "dev-browser-screenshot.png");
+const fullScreenshotPath = join(tmpdir(), "dev-browser-full.png");
+await page.screenshot({ path: screenshotPath });
+await page.screenshot({ path: fullScreenshotPath, fullPage: true });
 ```
 
+Inspect the files, then remove them no later than task completion.
+
 ### ARIA Snapshot (Element Discovery)
 
 Use `getAISnapshot()` to discover page elements. Returns YAML-formatted accessibility tree:
@@ -222,26 +242,26 @@ await element.click();
 
 ## Error Recovery
 
-Page state persists after failures. To inspect the current state, save a short script such as `tmp/debug.ts` and run it from the `dev-browser` skill directory:
-
-```typescript
-import { connect } from "@/client.js";
+Page state persists after failures while the server process runs. Reuse the external script pattern above from the OS temporary directory or task workspace:
 
+```javascript
 const client = await connect();
 const page = await client.page("hackernews");
 
-await page.screenshot({ path: "tmp/debug.png" });
+const debugScreenshotPath = join(tmpdir(), "dev-browser-debug.png");
+await page.screenshot({ path: debugScreenshotPath });
 console.log({
   url: page.url(),
   title: await page.title(),
   bodyText: await page.textContent("body").then((t) => t?.slice(0, 200)),
+  debugScreenshotPath,
 });
 
 await client.disconnect();
 ```
 
-Run it with:
+Run it with the same cross-platform invocation and delete the debug script and screenshot when finished:
 
 ```text
-npx tsx tmp/debug.ts
+node "PATH_TO_DEBUG_SCRIPT.mjs" "PATH_TO_INSTALLED_DEV_BROWSER"
 ```

package/skills/dev-browser/dist/scripts/start.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=start.d.ts.map

package/skills/dev-browser/dist/scripts/start.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"start.d.ts","sourceRoot":"","sources":["../../scripts/start.ts"],"names":[],"mappings":""}