monomind 1.14.7 → 1.15.0

package/packages/@monomind/cli/dist/src/browser/adapters/google.d.ts

@@ -0,0 +1,3 @@
+import type { PlatformAdapter } from './index.js';
+export declare const googleAdapter: PlatformAdapter;
+//# sourceMappingURL=google.d.ts.map

package/packages/@monomind/cli/dist/src/browser/adapters/google.js

@@ -0,0 +1,17 @@
+export const googleAdapter = {
+    platform: 'google',
+    baseURL: 'https://accounts.google.com',
+    reservedPaths: ['/signin', '/oauth', '/o/oauth2'],
+    loginURL: () => 'https://accounts.google.com/signin/v2/identifier',
+    async isLoggedIn(page) {
+        const url = await page.url();
+        // Logged in if we're on a Google service page (not the sign-in page)
+        if (url.includes('accounts.google.com/signin'))
+            return false;
+        return page.evaluate("!!(document.querySelector('[aria-label*=\"Google Account\"]') || document.querySelector('.gb_A') || document.cookie.includes('SSID'))");
+    },
+    async extractUsername(page) {
+        return page.evaluate("document.querySelector('[data-email]')?.getAttribute('data-email') ?? document.querySelector('.gb_A.gb_Sa')?.textContent?.trim() ?? ''");
+    },
+};
+//# sourceMappingURL=google.js.map

package/packages/@monomind/cli/dist/src/browser/adapters/index.d.ts

@@ -0,0 +1,19 @@
+import type { CdpClient } from '@monoes/monobrowse';
+export interface PageInterface {
+    client: CdpClient;
+    sessionId: string;
+    evaluate<T>(fn: string): Promise<T>;
+    url(): Promise<string>;
+}
+export interface PlatformAdapter {
+    platform: string;
+    baseURL: string;
+    reservedPaths: string[];
+    isLoggedIn(page: PageInterface): Promise<boolean>;
+    loginURL(): string;
+    extractUsername(page: PageInterface): Promise<string>;
+}
+export declare function registerAdapter(adapter: PlatformAdapter): void;
+export declare function getAdapter(platform: string): PlatformAdapter;
+export declare function listAdapters(): PlatformAdapter[];
+//# sourceMappingURL=index.d.ts.map

package/packages/@monomind/cli/dist/src/browser/adapters/index.js

@@ -0,0 +1,23 @@
+const registry = new Map();
+export function registerAdapter(adapter) {
+    registry.set(adapter.platform, adapter);
+}
+export function getAdapter(platform) {
+    const adapter = registry.get(platform);
+    if (!adapter)
+        throw new Error(`Unknown platform: ${platform}. Available: ${[...registry.keys()].join(', ')}`);
+    return adapter;
+}
+export function listAdapters() {
+    return [...registry.values()];
+}
+// Auto-register all adapters
+import { linkedinAdapter } from './linkedin.js';
+import { instagramAdapter } from './instagram.js';
+import { xAdapter } from './x.js';
+import { geminiAdapter } from './gemini.js';
+registerAdapter(linkedinAdapter);
+registerAdapter(instagramAdapter);
+registerAdapter(xAdapter);
+registerAdapter(geminiAdapter);
+//# sourceMappingURL=index.js.map

package/packages/@monomind/cli/dist/src/browser/adapters/instagram.d.ts

@@ -0,0 +1,3 @@
+import type { PlatformAdapter } from './index.js';
+export declare const instagramAdapter: PlatformAdapter;
+//# sourceMappingURL=instagram.d.ts.map

package/packages/@monomind/cli/dist/src/browser/adapters/instagram.js

@@ -0,0 +1,17 @@
+export const instagramAdapter = {
+    platform: 'instagram',
+    baseURL: 'https://www.instagram.com',
+    reservedPaths: ['/explore', '/reels', '/direct', '/stories', '/accounts', '/p', '/reel', '/tv'],
+    loginURL: () => 'https://www.instagram.com/accounts/login/',
+    async isLoggedIn(page) {
+        const url = await page.url();
+        if (url.includes('/accounts/login') || url.includes('/accounts/emailsignup'))
+            return false;
+        const hasAvatar = await page.evaluate(`!!document.querySelector('img[alt*="profile picture"], [aria-label="Home"]')`);
+        return hasAvatar;
+    },
+    async extractUsername(page) {
+        return page.evaluate(`(document.querySelector('a[href^="/"][href$="/"] span')?.textContent ?? 'unknown').trim()`);
+    },
+};
+//# sourceMappingURL=instagram.js.map

package/packages/@monomind/cli/dist/src/browser/adapters/linkedin.d.ts

@@ -0,0 +1,3 @@
+import type { PlatformAdapter } from './index.js';
+export declare const linkedinAdapter: PlatformAdapter;
+//# sourceMappingURL=linkedin.d.ts.map

package/packages/@monomind/cli/dist/src/browser/adapters/linkedin.js

@@ -0,0 +1,19 @@
+export const linkedinAdapter = {
+    platform: 'linkedin',
+    baseURL: 'https://www.linkedin.com',
+    reservedPaths: ['/feed', '/jobs', '/messaging', '/notifications', '/mynetwork', '/learning', '/search'],
+    loginURL: () => 'https://www.linkedin.com/login',
+    async isLoggedIn(page) {
+        const url = await page.url();
+        if (url.includes('/login') || url.includes('/authwall'))
+            return false;
+        const hasNav = await page.evaluate(`!!document.querySelector('[data-control-name="nav.home"] ,nav.global-nav')`);
+        return hasNav;
+    },
+    async extractUsername(page) {
+        const profileUrl = await page.evaluate(`(document.querySelector('a[href*="/in/"]')?.getAttribute('href') ?? '')`);
+        const match = profileUrl.match(/\/in\/([^/?#]+)/);
+        return match?.[1] ?? 'unknown';
+    },
+};
+//# sourceMappingURL=linkedin.js.map

package/packages/@monomind/cli/dist/src/browser/adapters/microsoft.d.ts

@@ -0,0 +1,3 @@
+import type { PlatformAdapter } from './index.js';
+export declare const microsoftAdapter: PlatformAdapter;
+//# sourceMappingURL=microsoft.d.ts.map

package/packages/@monomind/cli/dist/src/browser/adapters/microsoft.js

@@ -0,0 +1,16 @@
+export const microsoftAdapter = {
+    platform: 'microsoft',
+    baseURL: 'https://login.microsoftonline.com',
+    reservedPaths: ['/oauth2', '/common/oauth2', '/kmsi'],
+    loginURL: () => 'https://login.microsoftonline.com/common/oauth2/v2.0/authorize?client_id=common&response_type=code&scope=openid+profile+email',
+    async isLoggedIn(page) {
+        const url = await page.url();
+        if (url.includes('login.microsoftonline.com') || url.includes('login.microsoft.com'))
+            return false;
+        return page.evaluate("!!(document.querySelector('[data-tid=\"user-email\"]') || document.querySelector('.mectrl_currentAccount') || document.cookie.includes('ESTSAUTH'))");
+    },
+    async extractUsername(page) {
+        return page.evaluate("document.querySelector('[data-tid=\"user-email\"]')?.textContent?.trim() ?? document.querySelector('.mectrl_headerEmail')?.textContent?.trim() ?? ''");
+    },
+};
+//# sourceMappingURL=microsoft.js.map

package/packages/@monomind/cli/dist/src/browser/adapters/x.d.ts

@@ -0,0 +1,3 @@
+import type { PlatformAdapter } from './index.js';
+export declare const xAdapter: PlatformAdapter;
+//# sourceMappingURL=x.d.ts.map

package/packages/@monomind/cli/dist/src/browser/adapters/x.js

@@ -0,0 +1,19 @@
+export const xAdapter = {
+    platform: 'x',
+    baseURL: 'https://x.com',
+    reservedPaths: ['/home', '/explore', '/notifications', '/messages', '/i', '/search',
+        '/settings', '/bookmarks', '/lists', '/profile', '/compose', '/trending'],
+    loginURL: () => 'https://x.com/i/flow/login',
+    async isLoggedIn(page) {
+        const url = await page.url();
+        if (url.includes('/i/flow/login') || url.includes('/login'))
+            return false;
+        return page.evaluate(`!!document.querySelector('[data-testid="SideNav_AccountSwitcher_Button"]')`);
+    },
+    async extractUsername(page) {
+        return page.evaluate(`
+      (document.querySelector('[data-testid="UserName"] span')?.textContent ?? 'unknown').trim()
+    `);
+    },
+};
+//# sourceMappingURL=x.js.map

package/packages/@monomind/cli/dist/src/browser/dashboard/api-types.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Typed API response schemas for the monobrowse dashboard.
+ *
+ * These interfaces are the canonical contract between server.ts and
+ * dashboard clients (ui.html + any external consumers).  Changing a
+ * field name here will surface breakage at compile time rather than
+ * at runtime — preventing the field-name regression class documented
+ * in the sprint review (e.g. `msg` vs `message`, `tokensIn` vs
+ * `tokens_in`).
+ *
+ * @module @monomind/cli/browser/dashboard/api-types
+ */
+export interface OrgStatusResponse {
+    name: string;
+    status: 'ready' | 'running' | 'stopped';
+    currentRun?: RunRecord;
+}
+export interface RunRecord {
+    /** Stable run identifier (UUID or monotonic ID). */
+    id: string;
+    workflowId: string;
+    startedAt: number;
+    itemsProcessed: number;
+    status: string;
+}
+export interface SessionListResponse {
+    sessions: SessionEntry[];
+    total: number;
+}
+export interface SessionEntry {
+    sessionId: string;
+    name: string;
+    createdAt: string;
+}
+export interface BudgetResponse {
+    /** Input tokens consumed in this session/run. */
+    tokensIn: number;
+    /** Output tokens generated in this session/run. */
+    tokensOut: number;
+    /** Total monetary cost in `currency` units. */
+    totalCost: number;
+    currency: 'USD';
+}
+export interface ApiError {
+    /** Human-readable error message. */
+    error: string;
+    /** Optional machine-readable error code for programmatic handling. */
+    code?: string;
+}
+//# sourceMappingURL=api-types.d.ts.map

package/packages/@monomind/cli/dist/src/browser/dashboard/api-types.js

@@ -0,0 +1,14 @@
+/**
+ * Typed API response schemas for the monobrowse dashboard.
+ *
+ * These interfaces are the canonical contract between server.ts and
+ * dashboard clients (ui.html + any external consumers).  Changing a
+ * field name here will surface breakage at compile time rather than
+ * at runtime — preventing the field-name regression class documented
+ * in the sprint review (e.g. `msg` vs `message`, `tokensIn` vs
+ * `tokens_in`).
+ *
+ * @module @monomind/cli/browser/dashboard/api-types
+ */
+export {};
+//# sourceMappingURL=api-types.js.map

package/packages/@monomind/cli/dist/src/browser/dashboard/server.d.ts

@@ -0,0 +1,9 @@
+import type { StepEvent } from '../workflow/types.js';
+interface DashboardServer {
+    broadcast(event: StepEvent): void;
+    close(): void;
+    port: number;
+}
+export declare function getDashboardServer(port?: number): DashboardServer;
+export {};
+//# sourceMappingURL=server.d.ts.map

package/packages/@monomind/cli/dist/src/browser/dashboard/server.js

@@ -0,0 +1,62 @@
+import { createServer } from 'http';
+import { readFile } from 'fs/promises';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import { WebSocketServer } from 'ws';
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const DEFAULT_PORT = 4242;
+let instance = null;
+export function getDashboardServer(port = DEFAULT_PORT) {
+    if (instance)
+        return instance;
+    const recentRuns = [];
+    const clients = new Set();
+    const htmlPath = join(__dirname, 'ui.html');
+    const httpServer = createServer(async (req, res) => {
+        if (req.method === 'GET' && req.url === '/') {
+            try {
+                const html = await readFile(htmlPath, 'utf8');
+                res.writeHead(200, { 'Content-Type': 'text/html' });
+                res.end(html);
+            }
+            catch {
+                res.writeHead(500);
+                res.end('Dashboard UI not found');
+            }
+            return;
+        }
+        if (req.method === 'GET' && req.url === '/runs') {
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify(recentRuns));
+            return;
+        }
+        res.writeHead(404);
+        res.end();
+    });
+    const wss = new WebSocketServer({ server: httpServer });
+    wss.on('connection', (ws) => {
+        clients.add(ws);
+        // Send recent state on connect
+        ws.send(JSON.stringify({ type: 'init', runs: recentRuns }));
+        ws.on('close', () => clients.delete(ws));
+        ws.on('error', () => clients.delete(ws));
+    });
+    httpServer.listen(port);
+    instance = {
+        port,
+        broadcast(event) {
+            const msg = JSON.stringify(event);
+            for (const client of clients) {
+                if (client.readyState === client.OPEN)
+                    client.send(msg);
+            }
+        },
+        close() {
+            httpServer.close();
+            wss.close();
+            instance = null;
+        },
+    };
+    return instance;
+}
+//# sourceMappingURL=server.js.map