extension-develop 0.0.0-next-20250825144602

package/dist/add-hmr-accept-code.js

@@ -0,0 +1,96 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    default: ()=>add_hmr_accept_code
+});
+const external_fs_namespaceObject = require("fs");
+var external_fs_default = /*#__PURE__*/ __webpack_require__.n(external_fs_namespaceObject);
+const external_path_namespaceObject = require("path");
+var external_path_default = /*#__PURE__*/ __webpack_require__.n(external_path_namespaceObject);
+const external_loader_utils_namespaceObject = require("loader-utils");
+const external_schema_utils_namespaceObject = require("schema-utils");
+const schema = {
+    type: 'object',
+    properties: {
+        test: {
+            type: 'string'
+        },
+        manifestPath: {
+            type: 'string'
+        },
+        mode: {
+            type: 'string'
+        }
+    }
+};
+function add_hmr_accept_code(source) {
+    const options = this.getOptions();
+    const manifestPath = options.manifestPath;
+    const projectPath = external_path_default().dirname(manifestPath);
+    const manifest = JSON.parse(external_fs_default().readFileSync(manifestPath, 'utf-8'));
+    (0, external_schema_utils_namespaceObject.validate)(schema, options, {
+        name: "scripts:add-hmr-accept-code",
+        baseDataPath: 'options'
+    });
+    const url = (0, external_loader_utils_namespaceObject.urlToRequest)(this.resourcePath);
+    const reloadCode = `
+// TODO: cezaraugusto re-visit this
+if (import.meta.webpackHot) { import.meta.webpackHot.accept() };
+  `;
+    if (manifest.background) {
+        if (manifest.background.scripts) for (const bgScript of manifest.background.scripts){
+            const absoluteUrl = external_path_default().resolve(projectPath, bgScript);
+            if (url.includes(absoluteUrl)) return `${reloadCode}${source}`;
+        }
+    }
+    if (manifest.content_scripts) {
+        for (const contentScript of manifest.content_scripts)if (contentScript.js) for (const js of contentScript.js){
+            const absoluteUrl = external_path_default().resolve(projectPath, js);
+            if (url.includes(absoluteUrl)) return `${reloadCode}${source}`;
+        }
+    }
+    if (manifest.user_scripts) for (const userScript of manifest.user_scripts){
+        const absoluteUrl = external_path_default().resolve(projectPath, userScript);
+        if (url.includes(absoluteUrl)) return `${reloadCode}${source}`;
+    }
+    return source;
+}
+exports["default"] = __webpack_exports__["default"];
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "default"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/build.d.ts

@@ -0,0 +1,2 @@
+import { BuildOptions } from './develop-lib/config-types';
+export declare function extensionBuild(pathOrRemoteUrl: string | undefined, buildOptions?: BuildOptions): Promise<void>;

package/dist/cleanup.d.ts

@@ -0,0 +1 @@
+export declare function cleanupCommand(): Promise<void>;

package/dist/deprecated-shadow-root.js

@@ -0,0 +1,135 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    default: ()=>deprecated_shadow_root
+});
+const external_path_namespaceObject = require("path");
+const external_fs_namespaceObject = require("fs");
+const external_loader_utils_namespaceObject = require("loader-utils");
+const external_schema_utils_namespaceObject = require("schema-utils");
+const external_pintor_namespaceObject = require("pintor");
+var external_pintor_default = /*#__PURE__*/ __webpack_require__.n(external_pintor_namespaceObject);
+external_path_namespaceObject.join(process.cwd(), 'node_modules/extension-develop/dist/certs');
+const CHROMIUM_BASED_BROWSERS = [
+    'chrome',
+    'edge'
+];
+const GECKO_BASED_BROWSERS = [
+    'firefox'
+];
+[
+    ...CHROMIUM_BASED_BROWSERS,
+    ...GECKO_BASED_BROWSERS
+];
+function getLoggingPrefix(feature, type) {
+    if ('error' === type) return `${external_pintor_default().red('ERROR')} ${feature}`;
+    if ('warn' === type) return `${external_pintor_default().brightYellow("\u25BA\u25BA\u25BA")} ${feature}`;
+    const arrow = 'info' === type ? external_pintor_default().blue("\u25BA\u25BA\u25BA") : external_pintor_default().green("\u25BA\u25BA\u25BA");
+    return `${arrow} ${feature}`;
+}
+function deprecatedShadowRoot() {
+    return `${getLoggingPrefix('DEPRECATION', 'warn')} Using ${external_pintor_default().yellow('window.__EXTENSION_SHADOW_ROOT__')} in content_scripts is deprecated\nand will be removed in a future version of Extension.js. To use content_scripts with\nthe shadow DOM, see one of the many examples at:\nhttps://github.com/extension-js/extension.js/tree/main/examples\n\nIf you really need to use the shadow DOM as-is, the latest version of Extension.js\nto support it is ${external_pintor_default().gray('extension@2.0.0-beta.9')}.\n`;
+}
+const schema = {
+    type: 'object',
+    properties: {
+        test: {
+            type: 'string'
+        },
+        manifestPath: {
+            type: 'string'
+        }
+    }
+};
+function deprecated_shadow_root(source) {
+    const options = this.getOptions();
+    const manifestPath = options.manifestPath;
+    const projectPath = external_path_namespaceObject.dirname(manifestPath);
+    const manifest = JSON.parse(external_fs_namespaceObject.readFileSync(manifestPath, 'utf8'));
+    (0, external_schema_utils_namespaceObject.validate)(schema, options, {
+        name: "scripts:deprecated-shadow-root",
+        baseDataPath: 'options'
+    });
+    const url = (0, external_loader_utils_namespaceObject.urlToRequest)(this.resourcePath);
+    const patchCssTag = `
+;const appendStyleElementForLegacyShadowRoot = (legacyShadowRoot, stylesheets) => {
+  if (typeof chrome !== 'undefined' || typeof browser !== 'undefined') {
+    const styleElement = document.createElement('link')
+    styleElement.rel = 'stylesheet'
+    styleElement.href = (typeof chrome !== 'undefined' ? chrome : browser).runtime.getURL('content_scripts/content-0.css')
+    legacyShadowRoot.appendChild(styleElement)
+  }
+}
+
+function injectStyles() {
+  const legacyShadowRoot = window.__EXTENSION_SHADOW_ROOT__
+
+  if (legacyShadowRoot) {
+    appendStyleElementForLegacyShadowRoot(legacyShadowRoot)
+  } else {
+    // Use MutationObserver to wait for shadow root to be available
+    const observer = new MutationObserver(() => {
+      const shadowRoot = window.__EXTENSION_SHADOW_ROOT__
+
+      if (shadowRoot) {
+        appendStyleElementForLegacyShadowRoot(shadowRoot)
+        observer.disconnect()
+      }
+    })
+
+    observer.observe(document.body, { childList: true, subtree: true })
+  }
+};injectStyles();`;
+    if (manifest.content_scripts) {
+        for (const contentScript of manifest.content_scripts)if (contentScript.js) for (const js of contentScript.js){
+            const absoluteUrl = external_path_namespaceObject.resolve(projectPath, js);
+            if (url.includes(absoluteUrl)) {
+                if (source.includes('__EXTENSION_SHADOW_ROOT__')) {
+                    if ('development' === process.env.EXTENSION_ENV) console.warn(deprecatedShadowRoot());
+                    return `${patchCssTag}${source}`;
+                }
+                return `${source}`;
+            }
+        }
+    }
+    return source;
+}
+exports["default"] = __webpack_exports__["default"];
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "default"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/dev.d.ts

@@ -0,0 +1,2 @@
+import { DevOptions } from './develop-lib/config-types';
+export declare function extensionDev(pathOrRemoteUrl: string | undefined, devOptions: DevOptions): Promise<void>;

package/dist/develop-lib/config-types.d.ts

@@ -0,0 +1,85 @@
+import { Configuration } from '@rspack/core';
+export type BrowserType = 'chrome' | 'edge' | 'firefox' | 'chromium-based' | 'gecko-based';
+export interface BrowserOptionsBase {
+    open?: boolean;
+    profile?: string | false;
+    startingUrl?: string;
+    browser: BrowserType;
+}
+export interface ChromiumOptions extends BrowserOptionsBase {
+    browser: 'chromium-based';
+    chromiumBinary?: string;
+}
+export interface GeckoOptions extends BrowserOptionsBase {
+    browser: 'gecko-based';
+    geckoBinary?: string;
+}
+export interface NonBinaryOptions extends BrowserOptionsBase {
+    browser: Exclude<BrowserType, 'chromium-based' | 'gecko-based'>;
+}
+export type ExtendedBrowserOptions = ChromiumOptions | GeckoOptions | NonBinaryOptions;
+export interface DevOptions extends BrowserOptionsBase {
+    mode: 'development' | 'production' | 'none';
+    polyfill?: boolean;
+    port?: string | number | undefined;
+    chromiumBinary?: ChromiumOptions['chromiumBinary'];
+    geckoBinary?: GeckoOptions['geckoBinary'];
+    source?: string;
+    watchSource?: boolean;
+}
+export interface BuildOptions {
+    browser: BrowserOptionsBase['browser'];
+    zipFilename?: string;
+    zip?: boolean;
+    zipSource?: boolean;
+    polyfill?: boolean;
+    silent?: boolean;
+}
+export interface PreviewOptions extends BrowserOptionsBase {
+    mode: 'production';
+    outputPath?: string;
+    chromiumBinary?: ChromiumOptions['chromiumBinary'];
+    geckoBinary?: GeckoOptions['geckoBinary'];
+}
+export interface StartOptions extends BrowserOptionsBase {
+    mode: 'production';
+    polyfill?: boolean;
+    chromiumBinary?: ChromiumOptions['chromiumBinary'];
+    geckoBinary?: GeckoOptions['geckoBinary'];
+}
+export interface BrowserConfig extends BrowserOptionsBase {
+    browserFlags?: string[];
+    excludeBrowserFlags?: string[];
+    preferences?: Record<string, unknown>;
+    chromiumBinary?: ChromiumOptions['chromiumBinary'];
+    geckoBinary?: GeckoOptions['geckoBinary'];
+    reuseProfile?: boolean;
+}
+export interface FileConfig {
+    browser?: {
+        chrome?: BrowserConfig;
+        firefox?: BrowserConfig;
+        edge?: BrowserConfig;
+        'chromium-based'?: BrowserConfig;
+        'gecko-based'?: BrowserConfig;
+    };
+    commands?: {
+        dev?: Pick<DevOptions, 'browser' | 'profile' | 'chromiumBinary' | 'geckoBinary' | 'open' | 'polyfill'> & {
+            browserFlags?: string[];
+            excludeBrowserFlags?: string[];
+            preferences?: Record<string, unknown>;
+        };
+        start?: Pick<StartOptions, 'browser' | 'profile' | 'chromiumBinary' | 'geckoBinary' | 'polyfill'> & {
+            browserFlags?: string[];
+            excludeBrowserFlags?: string[];
+            preferences?: Record<string, unknown>;
+        };
+        preview?: Pick<PreviewOptions, 'browser' | 'profile' | 'chromiumBinary' | 'geckoBinary'> & {
+            browserFlags?: string[];
+            excludeBrowserFlags?: string[];
+            preferences?: Record<string, unknown>;
+        };
+        build?: Pick<BuildOptions, 'browser' | 'zipFilename' | 'zip' | 'zipSource' | 'polyfill'>;
+    };
+    config?: (config: Configuration) => Configuration;
+}

package/dist/develop-lib/extract-from-zip.d.ts

@@ -0,0 +1 @@
+export declare function downloadAndExtractZip(url: string, targetPath: string): Promise<string>;

package/dist/develop-lib/find-nearest-package.d.ts

@@ -0,0 +1,2 @@
+export declare function findNearestPackageJson(manifestPath: string): Promise<string | null>;
+export declare function validatePackageJson(packageJsonPath: string): boolean;

package/dist/develop-lib/generate-extension-types.d.ts

@@ -0,0 +1 @@
+export declare function generateExtensionTypes(projectPath: string): Promise<void>;

package/dist/develop-lib/generate-zip.d.ts

@@ -0,0 +1,2 @@
+import { type BuildOptions } from './config-types';
+export declare function generateZip(projectDir: string, { browser, ...options }: BuildOptions): Promise<void>;

package/dist/develop-lib/get-extension-config.d.ts

@@ -0,0 +1,6 @@
+import { Configuration } from '@rspack/core';
+import { BrowserConfig, DevOptions } from './config-types';
+export declare function loadCustomWebpackConfig(projectPath: string): Promise<(config: Configuration) => Configuration>;
+export declare function loadCommandConfig(projectPath: string, command: 'dev' | 'build' | 'start' | 'preview'): Promise<{}>;
+export declare function loadBrowserConfig(projectPath: string, browser?: DevOptions['browser']): Promise<BrowserConfig>;
+export declare function isUsingExperimentalConfig(projectPath: string): Promise<boolean>;

package/dist/develop-lib/get-project-path.d.ts

@@ -0,0 +1,6 @@
+export interface ProjectStructure {
+    manifestPath: string;
+    packageJsonPath: string;
+}
+export declare function getProjectPath(pathOrRemoteUrl: string | undefined): Promise<string>;
+export declare function getProjectStructure(pathOrRemoteUrl: string | undefined): Promise<ProjectStructure>;

package/dist/develop-lib/install-dependencies.d.ts

@@ -0,0 +1,2 @@
+export declare function getInstallCommand(): Promise<string>;
+export declare function installDependencies(projectPath: string): Promise<void>;

package/dist/develop-lib/messages.d.ts

@@ -0,0 +1,35 @@
+import { Manifest } from '../webpack/webpack-types';
+import { type DevOptions } from './config-types';
+export declare function manifestNotFoundError(manifestPath: string): string;
+export declare function packageJsonNotFoundError(manifestPath: string): string;
+export declare function building(browser: DevOptions['browser']): string;
+export declare function runningInProduction(outputPath: string): string;
+export declare function ready(mode: DevOptions['mode'], browser: DevOptions['browser']): string;
+export declare function previewing(browser: DevOptions['browser']): string;
+export declare function previewWebpack(): string;
+export declare function buildWebpack(projectDir: string, stats: any, browser: DevOptions['browser']): string;
+export declare function buildSuccess(): string;
+export declare function fetchingProjectPath(owner: string, project: string): string;
+export declare function downloadingProjectPath(projectName: string): string;
+export declare function creatingProjectPath(projectPath: string): string;
+export declare function noGitIgnoreFound(projectDir: string): string;
+export declare function packagingSourceFiles(zipPath: string): string;
+export declare function packagingDistributionFiles(zipPath: string): string;
+export declare function treeWithSourceAndDistFiles(browser: DevOptions['browser'], name: string, sourceZip: string, destZip: string): string;
+export declare function treeWithDistFilesbrowser(name: string, ext: string, browser: DevOptions['browser'], zipPath: string): string;
+export declare function treeWithSourceFiles(name: string, ext: string, browser: DevOptions['browser'], zipPath: string): string;
+export declare function failedToCompressError(error: any): string;
+export declare function writingTypeDefinitions(manifest: Manifest): string;
+export declare function writingTypeDefinitionsError(error: any): string;
+export declare function downloadingText(url: string): string;
+export declare function unpackagingExtension(zipFilePath: string): string;
+export declare function unpackagedSuccessfully(): string;
+export declare function failedToDownloadOrExtractZIPFileError(error: any): string;
+export declare function isUsingExperimentalConfig(integration: any): string;
+export declare function installingDependencies(): string;
+export declare function installingDependenciesFailed(gitCommand: string, gitArgs: string[], code: number | null): string;
+export declare function installingDependenciesProcessError(error: any): string;
+export declare function cantInstallDependencies(error: any): string;
+export declare function portInUse(requestedPort: number, newPort: number): string;
+export declare function configLoadingError(configPath: string, error: unknown): string;
+export declare function managedDependencyConflict(duplicates: string[], userPackageJsonPath: string): string;

package/dist/develop-lib/validate-user-dependencies.d.ts

@@ -0,0 +1 @@
+export declare function assertNoManagedDependencyConflicts(userPackageJsonPath: string, projectPath: string): void;

package/dist/ensure-hmr-for-scripts.js

@@ -0,0 +1,74 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    default: ()=>ensureHMRForScripts
+});
+const external_path_namespaceObject = require("path");
+const external_loader_utils_namespaceObject = require("loader-utils");
+const external_schema_utils_namespaceObject = require("schema-utils");
+const schema = {
+    type: 'object',
+    properties: {
+        test: {
+            type: 'string'
+        },
+        manifestPath: {
+            type: 'string'
+        },
+        includeList: {
+            type: 'object'
+        },
+        excludeList: {
+            type: 'object'
+        }
+    }
+};
+function ensureHMRForScripts(source) {
+    const options = this.getOptions();
+    const manifestPath = options.manifestPath;
+    external_path_namespaceObject.dirname(manifestPath);
+    try {
+        (0, external_schema_utils_namespaceObject.validate)(schema, options, {
+            name: "html:ensure-hmr-for-scripts",
+            baseDataPath: 'options'
+        });
+    } catch (error) {
+        throw error;
+    }
+    const resourcePath = this.resourcePath || '';
+    (0, external_loader_utils_namespaceObject.urlToRequest)(resourcePath);
+    const reloadCode = `
+if (import.meta.webpackHot) { import.meta.webpackHot.accept() }
+`;
+    return `${reloadCode}${source}`;
+}
+exports["default"] = __webpack_exports__["default"];
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "default"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/extensions/chrome-manager-extension/background.js

@@ -0,0 +1,58 @@
+import {createExtensionsPageTab, handleFirstRun} from './define-initial-tab.js'
+import {connect, disconnect, keepAlive} from './reload-service.js'
+
+function bgGreen(str) {
+  return `background: transparent; color: #0971fe; ${str}`
+}
+chrome.tabs.query({active: true}, async ([initialTab]) => {
+  console.log(
+    `%c
+██████████████████████████████████████████████████████████
+██████████████████████████████████████████████████████████
+████████████████████████████    ██████████████████████████
+█████████████████████████        ██████    ███████████████
+███████████████████████     ███   ███         ████████████
+██████████████████████    ██████        ███    ███████████
+███████████████████████     ██████    ██████   ███████████
+████████████████   ██████   ██████████████     ███████████
+█████████████       ████    ████████████      ████████████
+███████████     ██         █████████████   ███████████████
+██████████    ██████    █████████████████    █████████████
+███████████    ████████████████████████████    ███████████
+█████████████    █████████████████    ██████    ██████████
+███████████████   ██████████████        ██      ██████████
+████████████      ████████████    ████       █████████████
+███████████      █████████████   ██████    ███████████████
+███████████   ██████    ██████     ███████████████████████
+███████████    ████       ██████    ██████████████████████
+████████████         ██    ███     ███████████████████████
+███████████████    ██████        █████████████████████████
+██████████████████████████    ████████████████████████████
+██████████████████████████████████████████████████████████
+██████████████████████████████████████████████████████████
+MIT (c) ${new Date().getFullYear()} - Cezar Augusto and the Extension.js Authors.
+`,
+    bgGreen('')
+  )
+
+  if (
+    initialTab.url === 'chrome://newtab/' ||
+    initialTab.url === 'chrome://welcome/'
+  ) {
+    await handleFirstRun()
+  } else {
+    createExtensionsPageTab(initialTab, 'chrome://extensions/')
+  }
+})
+
+chrome.runtime.onInstalled.addListener(async () => {
+  let isConnected = false
+
+  if (isConnected) {
+    disconnect()
+  } else {
+    await connect()
+    isConnected = true
+    keepAlive()
+  }
+})

package/dist/extensions/chrome-manager-extension/define-initial-tab.js

@@ -0,0 +1,77 @@
+async function getDevExtension() {
+  const allExtensions = await new Promise((resolve) => {
+    chrome.management.getAll(resolve)
+  })
+
+  const devExtensions = allExtensions.filter((extension) => {
+    return (
+      // Do not include itself
+      extension.id !== chrome.runtime.id &&
+      // Reload extension
+      extension.id !== 'igcijhgmihmjbbahdabahfbpffalcfnn' &&
+      // Show only unpackaged extensions
+      extension.installType === 'development'
+    )
+  })
+
+  return devExtensions[0]
+}
+
+// Ideas here are adapted from
+// https://github.com/jeremyben/webpack-chrome-extension-launcher
+// Released under MIT license.
+
+// Create a new tab and set it to background.
+// We want the user-selected page to be active,
+// not chrome://extensions.
+export function createExtensionsPageTab(initialTab, url) {
+  // Check if url tab is open
+  chrome.tabs.query({url: 'chrome://extensions/'}, (tabs) => {
+    const extensionsTabExist = tabs.length > 0
+
+    // Return if url exists
+    if (extensionsTabExist) return
+
+    // Create an inactive tab
+    chrome.tabs.create(
+      {url, active: false},
+      function setBackgroundTab(extensionsTab) {
+        // Get current url tab and move it left.
+        // This action auto-activates the tab
+        chrome.tabs.move(extensionsTab.id, {index: 0}, () => {
+          // Get user-selected initial page tab and activate the right tab
+          setTimeout(() => {
+            chrome.tabs.update(initialTab.id, {active: true})
+          }, 500)
+        })
+      }
+    )
+  })
+}
+
+// Function to handle first run logic
+export async function handleFirstRun() {
+  chrome.tabs.update({url: 'chrome://extensions/'})
+
+  const devExtension = await getDevExtension()
+
+  chrome.storage.local.get(devExtension.id, (result) => {
+    if (result[devExtension.id] && result[devExtension.id].didRun) {
+      return
+    }
+
+    // Guard against opening multiple welcome pages
+    chrome.tabs.query(
+      {url: chrome.runtime.getURL('pages/welcome.html')},
+      (tabs) => {
+        if (Array.isArray(tabs) && tabs.length > 0) {
+          // Already open; do not create another
+          return
+        }
+        chrome.tabs.create({url: 'pages/welcome.html'})
+      }
+    )
+    // Ensure the welcome page shows only once per extension installation
+    chrome.storage.local.set({[devExtension.id]: {didRun: true}})
+  })
+}

package/dist/extensions/chrome-manager-extension/manifest.json

@@ -0,0 +1,17 @@
+{
+  "name": "Extension.js DevTools",
+  "description": "Extension.js built-in developer tools for browser instance ID __INSTANCE_ID__",
+  "version": "1.0.0",
+  "manifest_version": 3,
+  "key": "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAolEJq/DBHxY5dBpOqBRWNCl7vRPBvJPlpEzF19fYFVzzaH44AF6+sKjN3jwIKlsgI82F3TIuwoNFiN1yBu5Unf8SVBE4BTO92P02/ACcGYQxicgCLFUGQKlq4uSrwSPaBYl7FHcYl5SERgxnIGCGnaGMdL2vC7waCj2/U/iKoBF9I1lBH9/aKCSjTd3h2UYo7gg6n5nY/ENbzylDt42T3ATmvnVJfYhSNKA9Dv/zryknfnHYYgBKHtz7pDZwWnYdxs78n2VEKwGj7TgbXuIPDpCkrMnU9PTKpHbXFYARA4H9qYORQmYazfIxUZRnKQNSR+GAOGrb8JK+ijeQdwzDAwIDAQAB",
+  "background": {
+    "service_worker": "background.js",
+    "type": "module"
+  },
+  "icons": {
+    "16": "images/logo.png",
+    "48": "images/logo.png",
+    "128": "images/logo.png"
+  },
+  "permissions": ["management", "tabs", "storage"]
+}