sliccy 0.1.0

package/dist/cli/launch-url.d.ts

@@ -0,0 +1,9 @@
+export interface CliLaunchUrlOptions {
+    serveOrigin: string;
+    lead: boolean;
+    leadWorkerBaseUrl?: string | null;
+    envWorkerBaseUrl?: string | null;
+    join: boolean;
+    joinUrl?: string | null;
+}
+export declare function resolveCliBrowserLaunchUrl(options: CliLaunchUrlOptions): string;

package/dist/cli/launch-url.js

@@ -0,0 +1,34 @@
+import { buildCanonicalTrayLaunchUrl, normalizeTrayWorkerBaseUrl, parseTrayJoinUrl, } from '../tray-url-shared.js';
+function buildTrayJoinLaunchUrl(locationHref, joinUrl) {
+    const parsedJoinUrl = parseTrayJoinUrl(joinUrl);
+    if (!parsedJoinUrl) {
+        throw new Error(`Invalid tray join URL: ${joinUrl}`);
+    }
+    return buildCanonicalTrayLaunchUrl(locationHref, parsedJoinUrl.joinUrl);
+}
+function buildTrayLeadLaunchUrl(locationHref, workerBaseUrl) {
+    const normalizedBase = normalizeTrayWorkerBaseUrl(workerBaseUrl);
+    if (!normalizedBase) {
+        throw new Error(`Invalid tray worker base URL: ${workerBaseUrl}`);
+    }
+    return buildCanonicalTrayLaunchUrl(locationHref, normalizedBase);
+}
+export function resolveCliBrowserLaunchUrl(options) {
+    if (options.lead && options.join) {
+        throw new Error('The --lead and --join launch flows are mutually exclusive.');
+    }
+    if (options.join) {
+        if (!options.joinUrl) {
+            throw new Error('The --join launch flow requires a tray join URL via --join <url> or --join=<url>.');
+        }
+        return buildTrayJoinLaunchUrl(options.serveOrigin, options.joinUrl);
+    }
+    if (!options.lead) {
+        return options.serveOrigin;
+    }
+    const workerBaseUrl = normalizeTrayWorkerBaseUrl(options.leadWorkerBaseUrl ?? options.envWorkerBaseUrl ?? null);
+    if (!workerBaseUrl) {
+        throw new Error('The --lead launch flow requires a tray worker base URL via --lead <url>, --lead=<url>, or WORKER_BASE_URL.');
+    }
+    return buildTrayLeadLaunchUrl(options.serveOrigin, workerBaseUrl);
+}

package/dist/cli/qa-setup.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cli/qa-setup.js

@@ -0,0 +1,36 @@
+import { existsSync } from 'fs';
+import { resolve } from 'path';
+import { fileURLToPath } from 'url';
+import { CLI_PROFILE_NAMES, ensureQaProfileScaffold, findChromeExecutable, resolveQaProfilesRoot, } from './chrome-launch.js';
+const __dirname = fileURLToPath(new URL('.', import.meta.url));
+const projectRoot = resolve(__dirname, '..', '..');
+async function main() {
+    const chromePath = findChromeExecutable();
+    if (!chromePath) {
+        console.error('Could not find Chrome or Chrome for Testing. Set CHROME_PATH and retry.');
+        process.exit(1);
+    }
+    const extensionPath = resolve(projectRoot, 'dist', 'extension');
+    if (!existsSync(extensionPath)) {
+        console.error('dist/extension was not found. Run `npm run build:extension` first.');
+        process.exit(1);
+    }
+    const profiles = await ensureQaProfileScaffold(projectRoot);
+    console.log('SLICC QA profiles are ready.');
+    console.log(`Chrome executable: ${chromePath}`);
+    console.log(`QA profile root: ${resolveQaProfilesRoot(projectRoot)}`);
+    console.log(`Extension build: ${extensionPath}`);
+    console.log('Profiles:');
+    for (const profile of profiles) {
+        const extensionLabel = profile.extensionPath ? ' (auto-loads dist/extension)' : '';
+        console.log(`- ${profile.id}: ${profile.userDataDir}${extensionLabel}`);
+    }
+    console.log('Next commands:');
+    for (const profileName of CLI_PROFILE_NAMES) {
+        console.log(`- npm run qa:${profileName}`);
+    }
+}
+void main().catch((error) => {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+});

package/dist/cli/release-package.d.ts

@@ -0,0 +1,17 @@
+interface ZipEntry {
+    path: string;
+    data: Buffer;
+    mode: number;
+}
+interface ReleaseManifest {
+    version: string;
+    extensionArchive: string;
+    npmPackageTarball: string;
+}
+export declare function sanitizeArtifactName(value: string): string;
+export declare function assertMatchingVersions(packageVersion: string, extensionVersion: string): void;
+export declare function collectZipEntries(rootDir: string): ZipEntry[];
+export declare function createDeterministicZip(entries: readonly ZipEntry[]): Buffer;
+export declare function parseNpmPackFilename(output: string): string;
+export declare function packageReleaseArtifacts(): ReleaseManifest;
+export {};

package/dist/cli/release-package.js

@@ -0,0 +1,232 @@
+import { spawnSync } from 'child_process';
+import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync, statSync, writeFileSync, } from 'fs';
+import { resolve, relative, join } from 'path';
+import { fileURLToPath } from 'url';
+import { deflateRawSync } from 'zlib';
+const __dirname = fileURLToPath(new URL('.', import.meta.url));
+const PROJECT_ROOT = resolve(__dirname, '..', '..');
+const RELEASE_DIR = resolve(PROJECT_ROOT, 'artifacts', 'release');
+const FIXED_ZIP_DATE = new Date(Date.UTC(1980, 0, 1, 0, 0, 0));
+const ZIP_VERSION = 20;
+const ZIP_UTF8_FLAG = 0x0800;
+const ZIP_METHOD_DEFLATE = 8;
+const ZIP_FILE_MODE = 0o100644;
+const CRC32_TABLE = buildCrc32Table();
+function comparePaths(left, right) {
+    if (left < right)
+        return -1;
+    if (left > right)
+        return 1;
+    return 0;
+}
+export function sanitizeArtifactName(value) {
+    return value
+        .trim()
+        .toLowerCase()
+        .replace(/^@/, '')
+        .replace(/[\\/]+/g, '-')
+        .replace(/[^a-z0-9._-]+/g, '-')
+        .replace(/-+/g, '-')
+        .replace(/^-|-$/g, '');
+}
+export function assertMatchingVersions(packageVersion, extensionVersion) {
+    if (packageVersion !== extensionVersion) {
+        throw new Error(`package.json version (${packageVersion}) must match manifest.json version (${extensionVersion}) before packaging release artifacts.`);
+    }
+}
+export function collectZipEntries(rootDir) {
+    const entries = [];
+    const walk = (currentDir) => {
+        for (const name of readdirSync(currentDir).sort(comparePaths)) {
+            const fullPath = join(currentDir, name);
+            const stats = statSync(fullPath);
+            if (stats.isDirectory()) {
+                walk(fullPath);
+                continue;
+            }
+            if (!stats.isFile())
+                continue;
+            entries.push({
+                path: relative(rootDir, fullPath).split('\\').join('/'),
+                data: readFileSync(fullPath),
+                mode: ZIP_FILE_MODE,
+            });
+        }
+    };
+    walk(rootDir);
+    return entries;
+}
+export function createDeterministicZip(entries) {
+    const sortedEntries = [...entries].sort((left, right) => comparePaths(left.path, right.path));
+    const { dosDate, dosTime } = encodeDosDateTime(FIXED_ZIP_DATE);
+    const localSections = [];
+    const centralSections = [];
+    let offset = 0;
+    for (const entry of sortedEntries) {
+        const fileName = Buffer.from(entry.path, 'utf8');
+        const compressed = deflateRawSync(entry.data, { level: 9 });
+        const crc = crc32(entry.data);
+        const localHeader = Buffer.alloc(30);
+        localHeader.writeUInt32LE(0x04034b50, 0);
+        localHeader.writeUInt16LE(ZIP_VERSION, 4);
+        localHeader.writeUInt16LE(ZIP_UTF8_FLAG, 6);
+        localHeader.writeUInt16LE(ZIP_METHOD_DEFLATE, 8);
+        localHeader.writeUInt16LE(dosTime, 10);
+        localHeader.writeUInt16LE(dosDate, 12);
+        localHeader.writeUInt32LE(crc, 14);
+        localHeader.writeUInt32LE(compressed.length, 18);
+        localHeader.writeUInt32LE(entry.data.length, 22);
+        localHeader.writeUInt16LE(fileName.length, 26);
+        localHeader.writeUInt16LE(0, 28);
+        const localSection = Buffer.concat([localHeader, fileName, compressed]);
+        localSections.push(localSection);
+        const centralHeader = Buffer.alloc(46);
+        centralHeader.writeUInt32LE(0x02014b50, 0);
+        centralHeader.writeUInt16LE((3 << 8) | ZIP_VERSION, 4);
+        centralHeader.writeUInt16LE(ZIP_VERSION, 6);
+        centralHeader.writeUInt16LE(ZIP_UTF8_FLAG, 8);
+        centralHeader.writeUInt16LE(ZIP_METHOD_DEFLATE, 10);
+        centralHeader.writeUInt16LE(dosTime, 12);
+        centralHeader.writeUInt16LE(dosDate, 14);
+        centralHeader.writeUInt32LE(crc, 16);
+        centralHeader.writeUInt32LE(compressed.length, 20);
+        centralHeader.writeUInt32LE(entry.data.length, 24);
+        centralHeader.writeUInt16LE(fileName.length, 28);
+        centralHeader.writeUInt16LE(0, 30);
+        centralHeader.writeUInt16LE(0, 32);
+        centralHeader.writeUInt16LE(0, 34);
+        centralHeader.writeUInt16LE(0, 36);
+        centralHeader.writeUInt32LE((entry.mode << 16) >>> 0, 38);
+        centralHeader.writeUInt32LE(offset, 42);
+        const centralSection = Buffer.concat([centralHeader, fileName]);
+        centralSections.push(centralSection);
+        offset += localSection.length;
+    }
+    const centralDirectory = Buffer.concat(centralSections);
+    const endRecord = Buffer.alloc(22);
+    endRecord.writeUInt32LE(0x06054b50, 0);
+    endRecord.writeUInt16LE(0, 4);
+    endRecord.writeUInt16LE(0, 6);
+    endRecord.writeUInt16LE(sortedEntries.length, 8);
+    endRecord.writeUInt16LE(sortedEntries.length, 10);
+    endRecord.writeUInt32LE(centralDirectory.length, 12);
+    endRecord.writeUInt32LE(offset, 16);
+    endRecord.writeUInt16LE(0, 20);
+    return Buffer.concat([...localSections, centralDirectory, endRecord]);
+}
+function buildCrc32Table() {
+    const table = new Uint32Array(256);
+    for (let index = 0; index < 256; index += 1) {
+        let value = index;
+        for (let bit = 0; bit < 8; bit += 1) {
+            value = (value & 1) === 1 ? (value >>> 1) ^ 0xedb88320 : value >>> 1;
+        }
+        table[index] = value >>> 0;
+    }
+    return table;
+}
+function crc32(buffer) {
+    let crc = 0xffffffff;
+    for (const value of buffer) {
+        crc = CRC32_TABLE[(crc ^ value) & 0xff] ^ (crc >>> 8);
+    }
+    return (crc ^ 0xffffffff) >>> 0;
+}
+function encodeDosDateTime(value) {
+    const year = Math.max(value.getUTCFullYear(), 1980);
+    const dosDate = ((year - 1980) << 9)
+        | ((value.getUTCMonth() + 1) << 5)
+        | value.getUTCDate();
+    const dosTime = (value.getUTCHours() << 11)
+        | (value.getUTCMinutes() << 5)
+        | Math.floor(value.getUTCSeconds() / 2);
+    return { dosDate, dosTime };
+}
+function readJsonFile(path) {
+    return JSON.parse(readFileSync(path, 'utf8'));
+}
+function requirePath(path, description) {
+    if (!existsSync(path)) {
+        throw new Error(`${description} was not found at ${path}. Run the required build command(s) first.`);
+    }
+}
+function toProjectRelative(path) {
+    return relative(PROJECT_ROOT, path).split('\\').join('/');
+}
+function resolveNpmCommand() {
+    const npmExecPath = process.env['npm_execpath'];
+    if (npmExecPath) {
+        return { command: process.execPath, argsPrefix: [npmExecPath] };
+    }
+    return {
+        command: process.platform === 'win32' ? 'npm.cmd' : 'npm',
+        argsPrefix: [],
+    };
+}
+export function parseNpmPackFilename(output) {
+    const parsed = JSON.parse(output);
+    const filename = parsed[0]?.filename;
+    if (!filename) {
+        throw new Error(`npm pack did not report an output filename. Raw output: ${output.trim()}`);
+    }
+    return filename;
+}
+function createExtensionArchive(metadata) {
+    const extensionDir = resolve(PROJECT_ROOT, 'dist', 'extension');
+    requirePath(extensionDir, 'Extension build output');
+    const zipPath = resolve(RELEASE_DIR, `${sanitizeArtifactName(metadata.name)}-extension-v${metadata.version}.zip`);
+    const zipBuffer = createDeterministicZip(collectZipEntries(extensionDir));
+    writeFileSync(zipPath, zipBuffer);
+    return zipPath;
+}
+function createNpmPackageTarball() {
+    requirePath(resolve(PROJECT_ROOT, 'dist', 'cli'), 'CLI build output');
+    requirePath(resolve(PROJECT_ROOT, 'dist', 'ui'), 'UI build output');
+    const npm = resolveNpmCommand();
+    const result = spawnSync(npm.command, [...npm.argsPrefix, 'pack', '--json', '--ignore-scripts', '--pack-destination', RELEASE_DIR], {
+        cwd: PROJECT_ROOT,
+        encoding: 'utf8',
+        stdio: ['ignore', 'pipe', 'pipe'],
+    });
+    if (result.status !== 0) {
+        throw new Error((result.stderr || result.stdout || 'npm pack failed').trim());
+    }
+    return resolve(RELEASE_DIR, parseNpmPackFilename(result.stdout));
+}
+function writeReleaseManifest(manifest) {
+    const manifestPath = resolve(RELEASE_DIR, 'release-artifacts.json');
+    writeFileSync(manifestPath, `${JSON.stringify(manifest, null, 2)}\n`);
+    return manifestPath;
+}
+export function packageReleaseArtifacts() {
+    const packageJson = readJsonFile(resolve(PROJECT_ROOT, 'package.json'));
+    const extensionManifest = readJsonFile(resolve(PROJECT_ROOT, 'manifest.json'));
+    assertMatchingVersions(packageJson.version, extensionManifest.version);
+    rmSync(RELEASE_DIR, { recursive: true, force: true });
+    mkdirSync(RELEASE_DIR, { recursive: true });
+    const extensionArchive = createExtensionArchive(extensionManifest);
+    const npmPackageTarball = createNpmPackageTarball();
+    const manifest = {
+        version: packageJson.version,
+        extensionArchive: toProjectRelative(extensionArchive),
+        npmPackageTarball: toProjectRelative(npmPackageTarball),
+    };
+    writeReleaseManifest(manifest);
+    return manifest;
+}
+function main() {
+    const manifest = packageReleaseArtifacts();
+    console.log(`Created extension archive: ${manifest.extensionArchive}`);
+    console.log(`Created npm package tarball: ${manifest.npmPackageTarball}`);
+    console.log(`Created release manifest: ${toProjectRelative(resolve(RELEASE_DIR, 'release-artifacts.json'))}`);
+}
+if (process.argv[1] && fileURLToPath(import.meta.url) === resolve(process.argv[1])) {
+    try {
+        main();
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.error(`[package:release] ${message}`);
+        process.exit(1);
+    }
+}

package/dist/cli/runtime-flags.d.ts

@@ -0,0 +1,21 @@
+export type LogLevel = 'debug' | 'info' | 'warn' | 'error';
+export interface CliRuntimeFlags {
+    dev: boolean;
+    serveOnly: boolean;
+    cdpPort: number;
+    electron: boolean;
+    electronApp: string | null;
+    kill: boolean;
+    lead: boolean;
+    leadWorkerBaseUrl: string | null;
+    profile: string | null;
+    join: boolean;
+    joinUrl: string | null;
+    logLevel: LogLevel;
+    logDir: string | null;
+    /** Initial prompt to auto-submit when the UI loads */
+    prompt: string | null;
+}
+export declare const DEFAULT_CLI_CDP_PORT = 9222;
+export declare const DEFAULT_ELECTRON_ATTACH_CDP_PORT = 9223;
+export declare function parseCliRuntimeFlags(argv: string[]): CliRuntimeFlags;

package/dist/cli/runtime-flags.js

@@ -0,0 +1,154 @@
+export const DEFAULT_CLI_CDP_PORT = 9222;
+export const DEFAULT_ELECTRON_ATTACH_CDP_PORT = 9223;
+function looksLikeUrl(value) {
+    return /^[a-z][a-z0-9+.-]*:\/\//i.test(value.trim());
+}
+const VALID_LOG_LEVELS = new Set(['debug', 'info', 'warn', 'error']);
+export function parseCliRuntimeFlags(argv) {
+    let dev = false;
+    let serveOnly = false;
+    let cdpPort = DEFAULT_CLI_CDP_PORT;
+    let explicitCdpPort = false;
+    let electron = false;
+    let electronApp = null;
+    let kill = false;
+    let lead = false;
+    let leadWorkerBaseUrl = null;
+    let profile = null;
+    let join = false;
+    let joinUrl = null;
+    let logLevel = 'info';
+    let logDir = null;
+    let prompt = null;
+    for (let index = 0; index < argv.length; index += 1) {
+        const arg = argv[index];
+        if (arg === '--dev') {
+            dev = true;
+            continue;
+        }
+        if (arg === '--serve-only') {
+            serveOnly = true;
+            continue;
+        }
+        if (arg.startsWith('--cdp-port=')) {
+            const value = Number.parseInt(arg.slice('--cdp-port='.length), 10);
+            if (Number.isFinite(value) && value > 0) {
+                cdpPort = value;
+                explicitCdpPort = true;
+            }
+            continue;
+        }
+        if (arg.startsWith('--log-level=')) {
+            const value = arg.slice('--log-level='.length);
+            if (VALID_LOG_LEVELS.has(value)) {
+                logLevel = value;
+            }
+            continue;
+        }
+        if (arg.startsWith('--log-dir=')) {
+            logDir = arg.slice('--log-dir='.length) || null;
+            continue;
+        }
+        if (arg.startsWith('--prompt=')) {
+            prompt = arg.slice('--prompt='.length) || null;
+            continue;
+        }
+        if (arg === '--prompt') {
+            const nextArg = argv[index + 1];
+            if (nextArg && !nextArg.startsWith('--')) {
+                prompt = nextArg;
+                index += 1;
+            }
+            continue;
+        }
+        if (arg === '--electron') {
+            electron = true;
+            const nextArg = argv[index + 1];
+            if (nextArg && !nextArg.startsWith('--') && !electronApp) {
+                electronApp = nextArg.trim() || null;
+                index += 1;
+            }
+            continue;
+        }
+        if (arg === '--kill') {
+            kill = true;
+            continue;
+        }
+        if (arg === '--profile') {
+            const nextArg = argv[index + 1];
+            if (nextArg && !nextArg.startsWith('--')) {
+                profile = nextArg.trim() || null;
+                index += 1;
+            }
+            continue;
+        }
+        if (arg.startsWith('--profile=')) {
+            profile = arg.slice('--profile='.length).trim() || null;
+            continue;
+        }
+        if (arg === '--lead') {
+            lead = true;
+            const nextArg = argv[index + 1];
+            if (nextArg && !nextArg.startsWith('--') && looksLikeUrl(nextArg)) {
+                leadWorkerBaseUrl = nextArg.trim() || null;
+                index += 1;
+            }
+            continue;
+        }
+        if (arg.startsWith('--lead=')) {
+            lead = true;
+            leadWorkerBaseUrl = arg.slice('--lead='.length).trim() || null;
+            continue;
+        }
+        if (arg === '--join') {
+            join = true;
+            const nextArg = argv[index + 1];
+            if (nextArg && !nextArg.startsWith('--') && looksLikeUrl(nextArg)) {
+                joinUrl = nextArg.trim() || null;
+                index += 1;
+            }
+            continue;
+        }
+        if (arg.startsWith('--join=')) {
+            join = true;
+            joinUrl = arg.slice('--join='.length).trim() || null;
+            continue;
+        }
+        if (arg === '--electron-app') {
+            electron = true;
+            const nextArg = argv[index + 1];
+            if (nextArg && !nextArg.startsWith('--')) {
+                electronApp = nextArg.trim() || null;
+                index += 1;
+            }
+            continue;
+        }
+        if (arg.startsWith('--electron-app=')) {
+            electron = true;
+            electronApp = arg.slice('--electron-app='.length).trim() || null;
+            continue;
+        }
+        if (electron && !arg.startsWith('--') && !electronApp) {
+            electronApp = arg.trim() || null;
+        }
+    }
+    if (electron && !explicitCdpPort) {
+        cdpPort = DEFAULT_ELECTRON_ATTACH_CDP_PORT;
+    }
+    return {
+        dev,
+        serveOnly,
+        cdpPort,
+        electron,
+        electronApp,
+        kill,
+        lead,
+        leadWorkerBaseUrl,
+        profile,
+        join,
+        joinUrl,
+        logLevel,
+        logDir,
+        prompt,
+    };
+}

package/dist/cli/sync-release-version.d.ts

@@ -0,0 +1,2 @@
+export declare function updateManifestVersionContents(contents: string, version: string): string;
+export declare function writeManifestVersion(manifestPath: string, version: string): void;

package/dist/cli/sync-release-version.js

@@ -0,0 +1,34 @@
+import { readFileSync, writeFileSync } from 'fs';
+import { resolve } from 'path';
+import { fileURLToPath } from 'url';
+const __dirname = fileURLToPath(new URL('.', import.meta.url));
+const PROJECT_ROOT = resolve(__dirname, '..', '..');
+export function updateManifestVersionContents(contents, version) {
+    const manifest = JSON.parse(contents);
+    if (typeof manifest.version !== 'string') {
+        throw new Error('manifest.json must contain a string version before semantic-release can update it.');
+    }
+    manifest.version = version;
+    return `${JSON.stringify(manifest, null, 2)}\n`;
+}
+export function writeManifestVersion(manifestPath, version) {
+    writeFileSync(manifestPath, updateManifestVersionContents(readFileSync(manifestPath, 'utf8'), version));
+}
+function main() {
+    const version = process.argv[2];
+    if (!version) {
+        throw new Error('Usage: node dist/cli/sync-release-version.js <version>');
+    }
+    writeManifestVersion(resolve(PROJECT_ROOT, 'manifest.json'), version);
+    console.log(`Updated manifest.json version to ${version}`);
+}
+if (process.argv[1] && fileURLToPath(import.meta.url) === resolve(process.argv[1])) {
+    try {
+        main();
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.error(`[sync-release-version] ${message}`);
+        process.exit(1);
+    }
+}

package/dist/tray-url-shared.d.ts

@@ -0,0 +1,11 @@
+export declare const TRAY_QUERY_PARAM = "tray";
+export declare const TRAY_WORKER_QUERY_PARAM = "trayWorkerUrl";
+export declare const TRAY_LEGACY_LEAD_QUERY_PARAM = "lead";
+export interface ParsedTrayJoinUrl {
+    workerBaseUrl: string;
+    trayId: string;
+    joinUrl: string;
+}
+export declare function normalizeTrayWorkerBaseUrl(raw: string | null | undefined): string | null;
+export declare function parseTrayJoinUrl(raw: string | null | undefined): ParsedTrayJoinUrl | null;
+export declare function buildCanonicalTrayLaunchUrl(locationHref: string, trayValue: string): string;

package/dist/tray-url-shared.js

@@ -0,0 +1,56 @@
+export const TRAY_QUERY_PARAM = 'tray';
+export const TRAY_WORKER_QUERY_PARAM = 'trayWorkerUrl';
+export const TRAY_LEGACY_LEAD_QUERY_PARAM = 'lead';
+export function normalizeTrayWorkerBaseUrl(raw) {
+    if (!raw)
+        return null;
+    try {
+        const url = new URL(raw.trim());
+        url.search = '';
+        url.hash = '';
+        if (url.pathname !== '/') {
+            url.pathname = url.pathname.replace(/\/+$/, '') || '/';
+        }
+        const normalized = url.toString();
+        return normalized.endsWith('/') ? normalized.slice(0, -1) : normalized;
+    }
+    catch {
+        return null;
+    }
+}
+export function parseTrayJoinUrl(raw) {
+    if (!raw)
+        return null;
+    try {
+        const url = new URL(raw.trim());
+        url.search = '';
+        url.hash = '';
+        const normalizedJoinUrl = url.toString();
+        const segments = url.pathname.split('/').filter(Boolean);
+        if (segments.length < 2 || segments.at(-2) !== 'join') {
+            return null;
+        }
+        const token = decodeURIComponent(segments.at(-1));
+        const [trayId, secret, ...rest] = token.split('.');
+        if (!trayId || !secret || rest.length > 0) {
+            return null;
+        }
+        segments.splice(-2, 2);
+        url.pathname = segments.length > 0 ? `/${segments.join('/')}` : '/';
+        const workerBaseUrl = normalizeTrayWorkerBaseUrl(url.toString());
+        if (!workerBaseUrl) {
+            return null;
+        }
+        return { workerBaseUrl, trayId, joinUrl: normalizedJoinUrl };
+    }
+    catch {
+        return null;
+    }
+}
+export function buildCanonicalTrayLaunchUrl(locationHref, trayValue) {
+    const url = new URL(locationHref);
+    url.searchParams.delete(TRAY_WORKER_QUERY_PARAM);
+    url.searchParams.delete(TRAY_LEGACY_LEAD_QUERY_PARAM);
+    url.searchParams.set(TRAY_QUERY_PARAM, trayValue);
+    return url.toString();
+}

package/dist/ui/assets/___vite-browser-external_commonjs-proxy-7ULRRj69.js

@@ -0,0 +1 @@
+import{_ as e}from"./__vite-browser-external-D7Ct-6yo.js";import{g as r}from"./index-DvjzakYY.js";const a=r(e);export{a as r};

package/dist/ui/assets/__vite-browser-external-D7Ct-6yo.js

@@ -0,0 +1 @@
+const e={},t=Object.freeze(Object.defineProperty({__proto__:null,default:e},Symbol.toStringTag,{value:"Module"}));export{t as _};

package/dist/ui/assets/addon-fit-DOCEibfw.js

@@ -0,0 +1,12 @@
+/**
+ * Copyright (c) 2014-2024 The xterm.js authors. All rights reserved.
+ * @license MIT
+ *
+ * Copyright (c) 2012-2013, Christopher Jeffrey (MIT License)
+ * @license MIT
+ *
+ * Originally forked from (with the author's permission):
+ *   Fabrice Bellard's javascript vt100 for jslinux:
+ *   http://bellard.org/jslinux/
+ *   Copyright (c) 2011 Fabrice Bellard
+ */var p=2,c=1,d=class{activate(e){this._terminal=e}dispose(){}fit(){let e=this.proposeDimensions();if(!e||!this._terminal||isNaN(e.cols)||isNaN(e.rows))return;let i=this._terminal._core;(this._terminal.rows!==e.rows||this._terminal.cols!==e.cols)&&(i._renderService.clear(),this._terminal.resize(e.cols,e.rows))}proposeDimensions(){if(!this._terminal||!this._terminal.element||!this._terminal.element.parentElement)return;let e=this._terminal._core._renderService.dimensions;if(e.css.cell.width===0||e.css.cell.height===0)return;let i=this._terminal.options.scrollback===0?0:this._terminal.options.overviewRuler?.width||14,s=window.getComputedStyle(this._terminal.element.parentElement),l=parseInt(s.getPropertyValue("height")),o=Math.max(0,parseInt(s.getPropertyValue("width"))),t=window.getComputedStyle(this._terminal.element),r={top:parseInt(t.getPropertyValue("padding-top")),bottom:parseInt(t.getPropertyValue("padding-bottom")),right:parseInt(t.getPropertyValue("padding-right")),left:parseInt(t.getPropertyValue("padding-left"))},a=r.top+r.bottom,n=r.right+r.left,h=l-a,m=o-n-i;return{cols:Math.max(p,Math.floor(m/e.css.cell.width)),rows:Math.max(c,Math.floor(h/e.css.cell.height))}}};export{d as FitAddon};

package/dist/ui/assets/bsh-watchdog-D19WB0U1.js

@@ -0,0 +1,2 @@
+import{c as u}from"./index-DvjzakYY.js";const l=["/workspace","/shared"];async function d(s){const t=[],e=new Set;for(const r of l)await s.exists(r)&&await p(s,r,t,e);return t}async function p(s,t,e,r){for await(const n of s.walk(t)){if(!n.endsWith(".bsh")||r.has(n))continue;r.add(n);const i=g(n);if(!i)continue;const a=await s.readFile(n,{encoding:"utf-8"}),c=typeof a=="string"?a:new TextDecoder().decode(a),f=m(c);e.push({path:n,hostnamePattern:i,matchPatterns:f})}}function g(s){const t=s.split("/").pop()??"";if(!t.endsWith(".bsh"))return null;const e=t.slice(0,-4);return e?e.startsWith("-.")?"*"+e.slice(1):e:null}function m(s){const t=s.split(`
+`).slice(0,10),e=[];for(const r of t){const n=r.match(/^\s*\/\/\s*@match\s+(.+)$/);n&&e.push(n[1].trim())}return e}function h(s,t){if(t.startsWith("*.")){const e=t.slice(1);return s.endsWith(e)&&s.length>e.length}return s===t}function v(s,t){try{const e=new URL(s),r=t.match(/^(\*|https?):\/\/([^/]+)(\/.*)?$/);if(!r)return!1;const[,n,i,a]=r;return n!=="*"&&e.protocol.slice(0,-1)!==n||!h(e.hostname,i)?!1:a?x(e.pathname+e.search,a):!0}catch{return!1}}function x(s,t){const e="^"+t.replace(/[.+^${}()|[\]\\]/g,"\\$&").replace(/\*/g,".*")+"$";return new RegExp(e).test(s)}function w(s,t){try{const e=new URL(t);return s.filter(r=>h(e.hostname,r.hostnamePattern)?r.matchPatterns.length>0?r.matchPatterns.some(n=>v(t,n)):!0:!1)}catch{return[]}}const o=u("bsh-watchdog");class S{transport;fs;execute;discoveryIntervalMs;entries=[];discoveryTimer=null;running=!1;executing=new Set;constructor(t){this.transport=t.transport,this.fs=t.fs,this.execute=t.execute,this.discoveryIntervalMs=t.discoveryIntervalMs??3e4}async start(){this.running||(this.running=!0,await this.discover(),this.discoveryTimer=setInterval(()=>{this.discover()},this.discoveryIntervalMs),this.transport.on("Page.frameNavigated",this.onFrameNavigated),o.info("BSH watchdog started",{scriptCount:this.entries.length}))}stop(){this.running&&(this.running=!1,this.transport.off("Page.frameNavigated",this.onFrameNavigated),this.discoveryTimer&&(clearInterval(this.discoveryTimer),this.discoveryTimer=null),this.entries=[],this.executing.clear(),o.info("BSH watchdog stopped"))}async discover(){try{this.entries=await d(this.fs),o.debug("BSH discovery complete",{count:this.entries.length})}catch(t){o.error("BSH discovery failed",{error:t instanceof Error?t.message:String(t)})}}getEntries(){return this.entries}onFrameNavigated=t=>{const e=t.frame;if(e?.parentId||!e?.url)return;const r=e.url;if(!r.startsWith("http://")&&!r.startsWith("https://")||this.entries.length===0)return;const n=w(this.entries,r);if(n.length!==0)for(const i of n){const a=`${i.path}::${r}`;this.executing.has(a)||(this.executing.add(a),o.info("BSH watchdog executing script",{script:i.path,url:r}),this.execute(i.path).then(c=>{c.exitCode!==0?o.warn("BSH script failed",{script:i.path,url:r,exitCode:c.exitCode,stderr:c.stderr.slice(0,200)}):o.info("BSH script completed",{script:i.path,url:r})}).catch(c=>{o.error("BSH script execution error",{script:i.path,url:r,error:c instanceof Error?c.message:String(c)})}).finally(()=>{this.executing.delete(a)}))}}}export{S as BshWatchdog};