@jackwener/opencli 1.7.7 → 1.7.9

package/dist/src/browser/page.d.ts

@@ -15,8 +15,9 @@ import { BasePage } from './base-page.js';
  */
 export declare class Page extends BasePage {
     private readonly workspace;
+    readonly contextId?: string | undefined;
     private readonly _idleTimeout;
-    constructor(workspace?: string, idleTimeout?: number);
+    constructor(workspace?: string, idleTimeout?: number, contextId?: string | undefined);
     /** Active page identity (targetId), set after navigate and used in all subsequent commands */
     private _page;
     private _networkCaptureUnsupported;
@@ -28,6 +29,7 @@ export declare class Page extends BasePage {
     goto(url: string, options?: {
         waitUntil?: 'load' | 'none';
         settleMs?: number;
+        allowBoundNavigation?: boolean;
     }): Promise<void>;
     /** Get the active page identity (targetId) */
     getActivePage(): string | undefined;

package/dist/src/browser/page.js

@@ -27,10 +27,12 @@ function isUnsupportedNetworkCaptureError(err) {
  */
 export class Page extends BasePage {
     workspace;
+    contextId;
     _idleTimeout;
-    constructor(workspace = 'default', idleTimeout) {
+    constructor(workspace = 'default', idleTimeout, contextId) {
         super();
         this.workspace = workspace;
+        this.contextId = contextId;
         this._idleTimeout = idleTimeout;
     }
     /** Active page identity (targetId), set after navigate and used in all subsequent commands */
@@ -39,12 +41,17 @@ export class Page extends BasePage {
     _networkCaptureWarned = false;
     /** Helper: spread workspace into command params */
     _wsOpt() {
-        return { workspace: this.workspace, ...(this._idleTimeout != null && { idleTimeout: this._idleTimeout }) };
+        return {
+            workspace: this.workspace,
+            ...(this.contextId && { contextId: this.contextId }),
+            ...(this._idleTimeout != null && { idleTimeout: this._idleTimeout }),
+        };
     }
     /** Helper: spread workspace + page identity into command params */
     _cmdOpts() {
         return {
             workspace: this.workspace,
+            ...(this.contextId && { contextId: this.contextId }),
             ...(this._page !== undefined && { page: this._page }),
             ...(this._idleTimeout != null && { idleTimeout: this._idleTimeout }),
         };
@@ -53,6 +60,7 @@ export class Page extends BasePage {
         const result = await sendCommandFull('navigate', {
             url,
             ...this._cmdOpts(),
+            ...(options?.allowBoundNavigation === true && { allowBoundNavigation: true }),
         });
         // Remember the page identity (targetId) for subsequent calls
         if (result.page) {

package/dist/src/browser/profile.d.ts

@@ -0,0 +1,14 @@
+export declare const DEFAULT_CONTEXT_ID = "default";
+export type ProfileConfig = {
+    version: 1;
+    defaultContextId?: string;
+    aliases: Record<string, string>;
+};
+export declare function normalizeContextId(value: string | undefined | null): string | undefined;
+export declare function emptyProfileConfig(): ProfileConfig;
+export declare function loadProfileConfig(): ProfileConfig;
+export declare function saveProfileConfig(config: ProfileConfig): void;
+export declare function resolveProfileContextId(profile?: string): string | undefined;
+export declare function aliasForContextId(config: ProfileConfig, contextId: string): string | undefined;
+export declare function renameProfile(contextId: string, alias: string): ProfileConfig;
+export declare function setDefaultProfile(profile: string): ProfileConfig;

package/dist/src/browser/profile.js

@@ -0,0 +1,85 @@
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+export const DEFAULT_CONTEXT_ID = 'default';
+function profileConfigPath() {
+    const baseDir = process.env.OPENCLI_CONFIG_DIR || path.join(os.homedir(), '.opencli');
+    return path.join(baseDir, 'browser-profiles.json');
+}
+export function normalizeContextId(value) {
+    const trimmed = value?.trim();
+    return trimmed || undefined;
+}
+export function emptyProfileConfig() {
+    return { version: 1, aliases: {} };
+}
+export function loadProfileConfig() {
+    try {
+        const raw = fs.readFileSync(profileConfigPath(), 'utf-8');
+        const parsed = JSON.parse(raw);
+        const aliases = parsed.aliases && typeof parsed.aliases === 'object'
+            ? Object.fromEntries(Object.entries(parsed.aliases).filter((entry) => {
+                const [key, value] = entry;
+                return typeof key === 'string' && key.trim().length > 0
+                    && typeof value === 'string' && value.trim().length > 0;
+            }))
+            : {};
+        return {
+            version: 1,
+            aliases,
+            ...(typeof parsed.defaultContextId === 'string' && parsed.defaultContextId.trim()
+                ? { defaultContextId: parsed.defaultContextId.trim() }
+                : {}),
+        };
+    }
+    catch {
+        return emptyProfileConfig();
+    }
+}
+export function saveProfileConfig(config) {
+    const target = profileConfigPath();
+    fs.mkdirSync(path.dirname(target), { recursive: true });
+    fs.writeFileSync(target, JSON.stringify(config, null, 2) + '\n', 'utf-8');
+}
+export function resolveProfileContextId(profile) {
+    const config = loadProfileConfig();
+    const requested = normalizeContextId(profile)
+        ?? normalizeContextId(process.env.OPENCLI_PROFILE)
+        ?? normalizeContextId(config.defaultContextId);
+    if (!requested)
+        return undefined;
+    return config.aliases[requested] ?? requested;
+}
+export function aliasForContextId(config, contextId) {
+    for (const [alias, id] of Object.entries(config.aliases)) {
+        if (id === contextId)
+            return alias;
+    }
+    return undefined;
+}
+export function renameProfile(contextId, alias) {
+    const normalizedContextId = normalizeContextId(contextId);
+    const normalizedAlias = normalizeContextId(alias);
+    if (!normalizedContextId)
+        throw new Error('profile contextId is required');
+    if (!normalizedAlias)
+        throw new Error('profile alias is required');
+    const config = loadProfileConfig();
+    for (const [existingAlias, existingContextId] of Object.entries(config.aliases)) {
+        if (existingAlias !== normalizedAlias && existingContextId === normalizedContextId) {
+            delete config.aliases[existingAlias];
+        }
+    }
+    config.aliases[normalizedAlias] = normalizedContextId;
+    saveProfileConfig(config);
+    return config;
+}
+export function setDefaultProfile(profile) {
+    const contextId = resolveProfileContextId(profile) ?? normalizeContextId(profile);
+    if (!contextId)
+        throw new Error('profile is required');
+    const config = loadProfileConfig();
+    config.defaultContextId = contextId;
+    saveProfileConfig(config);
+    return config;
+}

package/dist/src/build-manifest.d.ts

@@ -39,5 +39,7 @@ export interface ManifestEntry {
     /** Pre-navigation control — see CliCommand.navigateBefore */
     navigateBefore?: boolean | string;
 }
+export declare function normalizeManifestPath(relativePath: string): string;
 export declare function loadManifestEntries(filePath: string, site: string, importer?: (moduleHref: string) => Promise<unknown>): Promise<ManifestEntry[]>;
 export declare function buildManifest(): Promise<ManifestEntry[]>;
+export declare function serializeManifest(manifest: ManifestEntry[]): string;

package/dist/src/build-manifest.js

@@ -36,6 +36,12 @@ function toModulePath(filePath, site) {
     const baseName = path.basename(filePath, path.extname(filePath));
     return `${site}/${baseName}.js`;
 }
+export function normalizeManifestPath(relativePath) {
+    return relativePath.replace(/\\/g, '/');
+}
+function toManifestRelativePath(filePath) {
+    return normalizeManifestPath(path.relative(CLIS_DIR, filePath));
+}
 function isCliCommandValue(value, site) {
     return isRecord(value)
         && typeof value.site === 'string'
@@ -85,8 +91,9 @@ export async function loadManifestEntries(filePath, site, importer = moduleHref
                 return !previous || previous !== cmd;
             })
                 .map(([, cmd]) => cmd);
-        // Resolve sourceFile relative to clis/.
-        const sourceRelative = path.relative(CLIS_DIR, filePath);
+        // Manifest paths are cross-platform artifacts; keep them POSIX-style even
+        // when build-manifest runs on Windows.
+        const sourceRelative = toManifestRelativePath(filePath);
         const seen = new Set();
         return runtimeCommands
             .filter((cmd) => {
@@ -128,10 +135,13 @@ export async function buildManifest() {
     }
     return [...manifest.values()].sort((a, b) => a.site.localeCompare(b.site) || a.name.localeCompare(b.name));
 }
+export function serializeManifest(manifest) {
+    return `${JSON.stringify(manifest, null, 2)}\n`;
+}
 async function main() {
     const manifest = await buildManifest();
     fs.mkdirSync(path.dirname(OUTPUT), { recursive: true });
-    fs.writeFileSync(OUTPUT, JSON.stringify(manifest, null, 2));
+    fs.writeFileSync(OUTPUT, serializeManifest(manifest));
     console.log(`✅ Manifest compiled: ${manifest.length} entries → ${OUTPUT}`);
     // Restore executable permissions on bin entries.
     // tsc does not preserve the +x bit, so after a clean rebuild the CLI

package/dist/src/build-manifest.test.js

@@ -3,7 +3,7 @@ import * as fs from 'node:fs';
 import * as os from 'node:os';
 import * as path from 'node:path';
 import { cli, getRegistry, Strategy } from './registry.js';
-import { loadManifestEntries } from './build-manifest.js';
+import { loadManifestEntries, normalizeManifestPath, serializeManifest } from './build-manifest.js';
 describe('manifest helper rules', () => {
     const tempDirs = [];
     afterEach(() => {
@@ -76,8 +76,9 @@ describe('manifest helper rules', () => {
                 replacedBy: 'opencli demo new',
             },
         ]);
-        // Verify sourceFile is included
+        // Verify sourceFile is included and stable for manifest consumers.
         expect(entries[0].sourceFile).toBeDefined();
+        expect(entries[0].sourceFile).not.toContain('\\');
         getRegistry().delete(key);
     });
     it('falls back to registry delta for side-effect-only cli modules', async () => {
@@ -139,4 +140,21 @@ describe('manifest helper rules', () => {
         getRegistry().delete(screenKey);
         getRegistry().delete(statusKey);
     });
+    it('normalizes manifest paths to POSIX separators', () => {
+        expect(normalizeManifestPath('demo\\status.js')).toBe('demo/status.js');
+        expect(normalizeManifestPath('demo/status.js')).toBe('demo/status.js');
+    });
+    it('serializes manifest json with a trailing newline', () => {
+        const serialized = serializeManifest([{
+                site: 'demo',
+                name: 'status',
+                description: '',
+                strategy: 'public',
+                browser: false,
+                args: [],
+                type: 'js',
+            }]);
+        expect(serialized.endsWith('\n')).toBe(true);
+        expect(serialized).toContain('\n]');
+    });
 });

package/dist/src/cli.d.ts

@@ -6,6 +6,12 @@
  */
 import { Command } from 'commander';
 import { findPackageRoot } from './package-paths.js';
+export declare function selectFreshByTimestamp<T extends {
+    timestamp?: unknown;
+}>(items: T[], lastSeenTs: number): {
+    fresh: T[];
+    lastSeenTs: number;
+};
 /**
  * Check whether the site-memory scaffolding exists under
  * ~/.opencli/sites/<site>/. Agents have a strong tendency to forget to write