@chronicle.app/chrome 0.0.0-stage → 0.4.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Andrew Louis
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,13 @@
-# Temporary Holding Version
+# @chronicle.app/chrome
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Read Chrome's `History` database with `ChromeExtractor`, then emit one `ViewAction` per page visit with `ChromeTransformer`. `input` defaults to the `History` file of the `profile` setting (`Default` unless set) in Chrome's profile directory on macOS, Linux, or Windows. The extractor reads a temporary copy of the database, read-only via built-in `node:sqlite` and removed when it finishes, so Chrome can keep its own open while it runs. A copy taken while Chrome was saving is taken again. On Linux, the profile directory follows `CHROME_CONFIG_HOME` or `XDG_CONFIG_HOME` when set.
+
+Records are visits, newest first. Redirect hops, pages loaded in frames, the extra visits Chrome adds to a search engine's keyword URL, pages that aren't on the web (`chrome://` and extension pages, files), visits imported from other browsers, and visits an extension added are left out. Visits synced from your other devices are included. `since`/`until` are exclusive visit-time bounds, and `limit: 0` means unlimited.
+
+Each `ViewAction` is keyed by the page's URL and its timestamp, to the millisecond. Chrome's visit id is only unique within one `History` file, but a synced visit keeps its time, so the same visit read on two devices is one node, and two pages opened in the same millisecond are two. The visited page is an `Entity` keyed by its URL and named after the page title, or the URL when there is none. Chrome keeps one title per URL, not per visit, so every visit to a page carries its latest title.
+
+The agent is the Google account the profile belongs to, read from its `Preferences`: the one signed in now, or else the last one that synced, which Chrome keeps after sign-out. It is the account's email address, lowercased, as an `email` Agent named by the account's name, `sameAs` the Google account, an Agent keyed by the same address in the `google-account` namespace: the nodes Gmail and Google Calendar make for you. `Preferences` lists every Google account signed in on the web too, so the profile's own is the one with its Gaia id; the id isn't recorded. A profile never signed in, or an account without an address, has no agent. The account is read when the run starts and applies to every visit in the file: History doesn't record who was signed in at each visit.
+
+A visit reached by following a link or submitting a form also becomes a `NavigateAction` at the same time: its `object` is the page you came from and its `target` the page you landed on, both keyed by URL, and it's keyed as the visit is, by its `target`'s URL and its timestamp. The page you came from is the one before in the same tab, or the page in the tab that opened it. Chrome also keeps a referrer as a URL when it isn't a visit, but for a link to another site browsers cut it to the site's home page, so it isn't used. For a redirected visit, it is where the redirect chain began. For a followed link, the page you came from also `references` the URL you followed, before any redirects. Typed URLs, bookmarks, reloads, and going back or forward have no `NavigateAction`, nor do steps from a page that isn't on the web or from the same page.
+
+[SHAPES.md](SHAPES.md) shows what each record type becomes; run `npm run shapes` to update it after changing the transformer. Tests use a synthetic history database and `Preferences` file and never read the host's browsing history.

package/dist/connectors/ChromeExtractor.d.ts

@@ -0,0 +1,63 @@
+import { Record } from '@chronicle.app/etl';
+import { SqliteExtractor } from '@chronicle.app/etl-sqlite';
+import ChromeTransformer from './ChromeTransformer.js';
+/** A link followed or a form submitted, from one page to the visit's. */
+export interface ChromeNavigation {
+    from_url: string;
+    /** The URL followed: the redirect chain's first, before any redirects. */
+    followed_url: string;
+    form_submit: boolean;
+}
+export declare class ChromeExtractor extends SqliteExtractor<typeof ChromeExtractor> {
+    static source: string;
+    static delivery: "local";
+    static strategy: string;
+    static description: string;
+    static default: boolean;
+    static recordTypes: string[];
+    static newestFirst: boolean;
+    /** Where Chrome keeps its profiles, per platform. */
+    static userDataDirs: {
+        [P in NodeJS.Platform]?: () => string;
+    };
+    static schema: any;
+    static defaultTransformer: typeof ChromeTransformer;
+    /** Chrome saves its history every few seconds: tries at copying it, and the wait between. */
+    static copyAttempts: number;
+    static copyRetryMs: number;
+    private account;
+    private referrerColumns;
+    private visitById;
+    private copyDir;
+    /** visits.id — Chrome's own visit id, AUTOINCREMENT so never reused. */
+    keyOf(record: Record): string | null;
+    setup(): Promise<void>;
+    /**
+     * Copy History into `dir`, to read it without Chrome's lock, and without
+     * holding the file Chrome writes, which could keep a Chrome that starts
+     * mid-run from opening it. A copy is whole when Chrome wasn't saving and
+     * the file didn't change while it was copied. A copy that caught a save is
+     * taken again.
+     */
+    private copyHistory;
+    teardown(): Promise<void>;
+    private userDataDir;
+    private visitFilter;
+    private static readonly FROM;
+    extract(): AsyncGenerator<Record>;
+    private processRow;
+    /**
+     * How the visit was reached by following a link or submitting a form: from
+     * the page before it in its tab, else the page in the tab that opened it.
+     * Read from the first visit of its redirect chain, as Chrome's own history
+     * features do. Null for a typed URL, a bookmark, a reload, going back or
+     * forward, or a page reached from itself or from a page that isn't on the
+     * web. Chrome also keeps a referrer that isn't a visit as a URL, but for a
+     * link to another site browsers cut it to that site's home page, which isn't
+     * the page you came from.
+     */
+    private navigation;
+    private visit;
+    determineCount(): Promise<number | null>;
+}
+//# sourceMappingURL=ChromeExtractor.d.ts.map

package/dist/connectors/ChromeExtractor.js

@@ -0,0 +1,267 @@
+import { constants as fsConstants, copyFileSync, mkdtempSync, rmSync, statSync } from 'node:fs';
+import { homedir, tmpdir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { EXIT_CODES, ExtractorError, delay } from '@chronicle.app/etl';
+import { SqliteExtractor, allRows, chromeToUnixMsSql, getRow, iterateRows, timeRangeConditions, unixMsToChromeTimestamp, } from '@chronicle.app/etl-sqlite';
+import { z } from 'zod';
+import ChromeTransformer from './ChromeTransformer.js';
+import { readChromeAccount } from './profile.js';
+// visits.transition: the low byte is the core type, the high bits qualifiers.
+// CHAIN_END marks the visit a redirect chain landed on (a visit with no
+// redirects is both start and end), so redirect hops drop out.
+const CHAIN_END = 0x20_00_00_00;
+const CORE_MASK = 0xff;
+// Core types that are not a page you visited: pages loaded inside a frame,
+// automatically or by a click there (3, 4), and the extra visit Chrome adds to
+// a search engine's keyword URL when you search from the address bar (10).
+const SKIPPED_TYPES = [3, 4, 10];
+// visit_source.source for visits you made: synced from another device (0) or
+// browsed here (1, which Chrome usually leaves unrecorded). Not ones an
+// extension added (2), or imported from another browser or device migration
+// (Firefox, IE, Safari, OS migration): another browser's history belongs to
+// that browser's source.
+const BROWSED_SOURCES = [0, 1];
+// Web pages only: not browser or extension pages, files, or blobs.
+const WEB_SCHEMES = ['http://', 'https://'];
+// A redirect chain's first visit: its transition says how the navigation
+// began, and its from_visit is the page it began on.
+const CHAIN_START = 0x10_00_00_00;
+const MAX_REDIRECTS = 20;
+// Core types for following something on a page: a link (0) or a form (7).
+const LINK = 0;
+const FORM_SUBMIT = 7;
+// Qualifiers for going back or forward (0x01000000) and for a URL entered in
+// the address bar (0x02000000): not a step from the page before.
+const NOT_FOLLOWED = 0x03_00_00_00;
+const visitTime = chromeToUnixMsSql('visits.visit_time');
+export class ChromeExtractor extends SqliteExtractor {
+    static source = 'chrome';
+    static delivery = 'local';
+    static strategy = 'app-db';
+    static description = 'Browsing history';
+    static default = true;
+    static recordTypes = ['views'];
+    // extract() orders by visits.visit_time desc, which with keyOf opts this
+    // extractor into the frontier cursor (incremental catch-up import).
+    static newestFirst = true;
+    /** Where Chrome keeps its profiles, per platform. */
+    static userDataDirs = {
+        darwin: () => join(homedir(), 'Library/Application Support/Google/Chrome'),
+        // Chrome's own override for ~/.config, then the XDG one.
+        linux: () => join(process.env.CHROME_CONFIG_HOME || process.env.XDG_CONFIG_HOME || join(homedir(), '.config'), 'google-chrome'),
+        win32: () => join(process.env.LOCALAPPDATA ?? join(homedir(), 'AppData/Local'), 'Google/Chrome/User Data'),
+    };
+    static schema = SqliteExtractor.schema.omit({ input: true }).extend({
+        input: z
+            .string()
+            .optional()
+            .describe("Path to a Chrome History file (defaults to the profile's)"),
+        profile: z
+            .string()
+            .default('Default')
+            .describe('Chrome profile directory name, such as Default or "Profile 1"'),
+    });
+    static defaultTransformer = ChromeTransformer;
+    /** Chrome saves its history every few seconds: tries at copying it, and the wait between. */
+    static copyAttempts = 5;
+    static copyRetryMs = 200;
+    account = null;
+    referrerColumns = '';
+    visitById = null;
+    copyDir = null;
+    /** visits.id — Chrome's own visit id, AUTOINCREMENT so never reused. */
+    keyOf(record) {
+        const visitId = record.data.visit_id;
+        return visitId === null || visitId === undefined ? null : String(visitId);
+    }
+    async setup() {
+        const cfg = this.config;
+        cfg.input ??= join(this.userDataDir(), cfg.profile, 'History');
+        // Says whether History is there and readable; the run reads a copy.
+        await super.setup();
+        this.db.close();
+        this.db = null;
+        this.copyDir = mkdtempSync(join(tmpdir(), 'chronicle-chrome-'));
+        try {
+            this.db = this.openDatabase(await this.copyHistory(cfg.input, this.copyDir));
+            this.account = readChromeAccount(join(dirname(cfg.input), 'Preferences'));
+            // History files from before 2022 have no opener.
+            const columns = new Set(allRows(this.db.prepare('PRAGMA table_info(visits)')).map(c => c.name));
+            this.referrerColumns = [
+                'visits.transition',
+                `visits.transition & ${CORE_MASK} AS core_type`,
+                `(visits.transition & ${CHAIN_START}) != 0 AS chain_start`,
+                `(visits.transition & ${NOT_FOLLOWED}) != 0 AS not_followed`,
+                'visits.from_visit',
+                columns.has('opener_visit') ? 'visits.opener_visit' : '0 AS opener_visit',
+            ].join(', ');
+            this.visitById = this.db.prepare(`
+        SELECT urls.url, ${this.referrerColumns}
+        FROM visits JOIN urls ON urls.id = visits.url
+        WHERE visits.id = ?`);
+        }
+        catch (error) {
+            await this.teardown();
+            throw error;
+        }
+    }
+    /**
+     * Copy History into `dir`, to read it without Chrome's lock, and without
+     * holding the file Chrome writes, which could keep a Chrome that starts
+     * mid-run from opening it. A copy is whole when Chrome wasn't saving and
+     * the file didn't change while it was copied. A copy that caught a save is
+     * taken again.
+     */
+    async copyHistory(history, dir) {
+        const cls = this.constructor;
+        const copy = join(dir, 'History');
+        for (let attempt = 1;; attempt++) {
+            const before = savedState(history);
+            copyFileSync(history, copy, fsConstants.COPYFILE_FICLONE);
+            if (before !== null && before === savedState(history))
+                return copy;
+            if (attempt >= cls.copyAttempts) {
+                throw new ExtractorError('Chrome kept saving its history', {
+                    code: 'input-busy',
+                    exitCode: EXIT_CODES.transient,
+                    hint: `Run \`chronicle extract ${cls.source}\` again in a moment.`,
+                    fields: { path: history },
+                });
+            }
+            await delay(cls.copyRetryMs);
+        }
+    }
+    async teardown() {
+        await super.teardown();
+        if (this.copyDir) {
+            rmSync(this.copyDir, { recursive: true, force: true });
+            this.copyDir = null;
+        }
+    }
+    userDataDir() {
+        const cls = this.constructor;
+        const dir = cls.userDataDirs[process.platform];
+        if (!dir)
+            throw new Error(`No default ${cls.source} profile on ${process.platform}; pass input`);
+        return dir();
+    }
+    // Visits that landed on a web page, browsed or synced, within since/until.
+    visitFilter() {
+        const range = timeRangeConditions('visits.visit_time', this.config, {
+            convert: date => unixMsToChromeTimestamp(date.getTime()),
+        });
+        const conditions = [
+            `(visits.transition & ${CHAIN_END}) != 0`,
+            `(visits.transition & ${CORE_MASK}) NOT IN (${SKIPPED_TYPES.join(', ')})`,
+            `(visit_source.source IS NULL OR visit_source.source IN (${BROWSED_SOURCES.join(', ')}))`,
+            `(${WEB_SCHEMES.map(() => `urls.url LIKE ? || '%'`).join(' OR ')})`,
+            ...range.conditions,
+        ];
+        return {
+            where: conditions.join(' AND '),
+            values: [...WEB_SCHEMES, ...range.values],
+        };
+    }
+    static FROM = `
+    FROM visits
+    JOIN urls ON urls.id = visits.url
+    LEFT JOIN visit_source ON visit_source.id = visits.id`;
+    async *extract() {
+        if (!this.db) {
+            throw new Error('Database not initialized');
+        }
+        // 0 is the "no limit" convention (null here); the CLI's --limit default is the safety net
+        const limit = this.getEffectiveLimit();
+        const { where, values } = this.visitFilter();
+        let sql = `
+      SELECT visits.id AS visit_id,
+             urls.url,
+             urls.title,
+             ${visitTime} AS unix_ms,
+             ${this.referrerColumns}
+      ${ChromeExtractor.FROM}
+      WHERE ${where}
+      ORDER BY visits.visit_time DESC`;
+        if (limit !== null) {
+            sql += ` LIMIT ?`;
+            values.push(limit);
+        }
+        const { account } = this;
+        for (const row of iterateRows(this.db.prepare(sql), ...values)) {
+            yield this.createRecord(this.processRow(row), { source: 'chrome', account });
+        }
+    }
+    processRow(row) {
+        return {
+            visit_id: row.visit_id,
+            url: row.url,
+            title: row.title || null,
+            unix_ms: row.unix_ms,
+            transition: row.transition,
+            navigation: this.navigation(row),
+        };
+    }
+    /**
+     * How the visit was reached by following a link or submitting a form: from
+     * the page before it in its tab, else the page in the tab that opened it.
+     * Read from the first visit of its redirect chain, as Chrome's own history
+     * features do. Null for a typed URL, a bookmark, a reload, going back or
+     * forward, or a page reached from itself or from a page that isn't on the
+     * web. Chrome also keeps a referrer that isn't a visit as a URL, but for a
+     * link to another site browsers cut it to that site's home page, which isn't
+     * the page you came from.
+     */
+    navigation(row) {
+        let start = row;
+        for (let hops = 0; !start.chain_start; hops++) {
+            const previous = hops < MAX_REDIRECTS ? this.visit(start.from_visit) : undefined;
+            if (!previous)
+                return null;
+            start = previous;
+        }
+        if (start.core_type !== LINK && start.core_type !== FORM_SUBMIT)
+            return null;
+        if (start.not_followed)
+            return null;
+        const from = this.visit(start.from_visit)?.url ?? this.visit(start.opener_visit)?.url;
+        if (!from || from === row.url || !WEB_SCHEMES.some(scheme => from.startsWith(scheme))) {
+            return null;
+        }
+        return {
+            from_url: from,
+            followed_url: start.url,
+            form_submit: start.core_type === FORM_SUBMIT,
+        };
+    }
+    visit(id) {
+        return id ? getRow(this.visitById, id) : undefined;
+    }
+    async determineCount() {
+        if (!this.db)
+            return null;
+        try {
+            // Same filters as the main query, counted
+            const { where, values } = this.visitFilter();
+            const row = this.db
+                .prepare(`SELECT COUNT(*) AS n ${ChromeExtractor.FROM} WHERE ${where}`)
+                .get(...values);
+            return row.n;
+        }
+        catch {
+            return null;
+        }
+    }
+}
+/**
+ * History's size and modification time while it holds only saved changes,
+ * or null while Chrome saves. Chrome keeps a transaction open between saves,
+ * and SQLite writes each change to the journal before the file, so the file
+ * is whole while its journal is empty or was written after it.
+ */
+function savedState(history) {
+    const file = statSync(history);
+    const journal = statSync(`${history}-journal`, { throwIfNoEntry: false });
+    if (journal && journal.size > 0 && journal.mtimeMs <= file.mtimeMs)
+        return null;
+    return `${file.size}:${file.mtimeMs}`;
+}

package/dist/connectors/ChromeTransformer.d.ts

@@ -0,0 +1,23 @@
+import { ChronicleTransformer, Record } from '@chronicle.app/etl';
+import { ActionAndChildren } from '@chronicle.app/schema';
+export default class ChromeTransformer extends ChronicleTransformer {
+    transform(record: Record): Promise<ActionAndChildren[]>;
+    private buildViewAction;
+    /**
+     * The step from the page you followed a link or submitted a form on to the
+     * page you landed on, at the same moment as the visit. Both pages are the
+     * bare URL nodes the visits name. A followed link is also evidence that its
+     * page links to the URL followed, before any redirects, so that page
+     * `references` it. A form's address is not a link on the page.
+     */
+    private buildNavigateAction;
+    /**
+     * The profile's Google account as you: its address, as Gmail and Google
+     * Calendar key you, `sameAs` the account, keyed by the same address in the
+     * `google-account` namespace they link you to.
+     */
+    private buildUser;
+    private buildWebPage;
+    private pageByUrl;
+}
+//# sourceMappingURL=ChromeTransformer.d.ts.map

package/dist/connectors/ChromeTransformer.js

@@ -0,0 +1,77 @@
+import { ChronicleTransformer, selfAgent } from '@chronicle.app/etl';
+import { googleAccount } from '@chronicle.app/google';
+export default class ChromeTransformer extends ChronicleTransformer {
+    async transform(record) {
+        const actions = [];
+        if (record.extraction.recordType === 'views') {
+            const user = this.buildUser(record.context.account);
+            actions.push(this.buildViewAction(record, user));
+            const navigation = record.data.navigation;
+            if (navigation)
+                actions.push(this.buildNavigateAction(record, navigation, user));
+        }
+        return actions;
+    }
+    buildViewAction(record, user) {
+        return {
+            '@type': 'ViewAction',
+            timestamp: new Date(record.data.unix_ms),
+            // Chrome's visit id is only unique within one History file, but a
+            // synced visit keeps its time, so the page and time are the visit on
+            // every device. Two pages can open in the same millisecond.
+            '@key': ['@type', 'source', 'object.url', 'timestamp'],
+            source: 'chrome',
+            // A profile never signed in can't identify the viewer, so omit them.
+            ...(user && { agent: user }),
+            object: this.buildWebPage(record),
+        };
+    }
+    /**
+     * The step from the page you followed a link or submitted a form on to the
+     * page you landed on, at the same moment as the visit. Both pages are the
+     * bare URL nodes the visits name. A followed link is also evidence that its
+     * page links to the URL followed, before any redirects, so that page
+     * `references` it. A form's address is not a link on the page.
+     */
+    buildNavigateAction(record, navigation, user) {
+        const followed = this.pageByUrl(navigation.followed_url);
+        return {
+            '@type': 'NavigateAction',
+            timestamp: new Date(record.data.unix_ms),
+            // Keyed as the visit is: the page landed on, and when.
+            '@key': ['@type', 'source', 'target.url', 'timestamp'],
+            source: 'chrome',
+            ...(user && { agent: user }),
+            object: {
+                ...this.pageByUrl(navigation.from_url),
+                ...(!navigation.form_submit && { references: [followed] }),
+            },
+            target: this.pageByUrl(record.data.url),
+        };
+    }
+    /**
+     * The profile's Google account as you: its address, as Gmail and Google
+     * Calendar key you, `sameAs` the account, keyed by the same address in the
+     * `google-account` namespace they link you to.
+     */
+    buildUser(account) {
+        if (!account)
+            return null;
+        return selfAgent({
+            type: 'Agent',
+            source: 'email',
+            handle: account.email,
+            ...(account.name && { name: account.name }),
+            sameAs: [googleAccount(account.email)],
+        });
+    }
+    buildWebPage(record) {
+        return {
+            ...this.pageByUrl(record.data.url),
+            name: record.data.title || record.data.url,
+        };
+    }
+    pageByUrl(url) {
+        return { '@type': 'Entity', '@key': ['url'], url };
+    }
+}

package/dist/connectors/profile.d.ts

@@ -0,0 +1,14 @@
+/** The Google account a Chrome profile is signed in to, by its address. */
+export interface ChromeAccount {
+    email: string;
+    /** The account's name, as Google shows it. */
+    name?: string;
+}
+/**
+ * Read the profile's account from its `Preferences` JSON: the one signed in
+ * now, else the last one that synced, which Chrome keeps after sign-out. A
+ * profile never signed in, an account without an address, or a missing or
+ * unreadable file has none: visits are still readable, with no agent.
+ */
+export declare function readChromeAccount(preferencesPath: string): ChromeAccount | null;
+//# sourceMappingURL=profile.d.ts.map

package/dist/connectors/profile.js

@@ -0,0 +1,34 @@
+import { readFileSync } from 'node:fs';
+/**
+ * Read the profile's account from its `Preferences` JSON: the one signed in
+ * now, else the last one that synced, which Chrome keeps after sign-out. A
+ * profile never signed in, an account without an address, or a missing or
+ * unreadable file has none: visits are still readable, with no agent.
+ */
+export function readChromeAccount(preferencesPath) {
+    let prefs;
+    try {
+        prefs = JSON.parse(readFileSync(preferencesPath, 'utf8'));
+    }
+    catch {
+        return null;
+    }
+    return readAccount(prefs);
+}
+// `sync.gaia_id` is the account signed in now, cleared at sign-out;
+// `google.services.last_gaia_id` is the last one that synced. `account_info`
+// lists every Google account signed in on the web as well, so the profile's
+// own is the entry with its Gaia id. The address is lowercased, as mail keys
+// it.
+function readAccount(prefs) {
+    const gaiaId = [prefs?.sync?.gaia_id, prefs?.google?.services?.last_gaia_id].find((id) => typeof id === 'string' && id !== '');
+    if (!gaiaId)
+        return null;
+    const info = Array.isArray(prefs?.account_info)
+        ? prefs.account_info.find((a) => a?.gaia === gaiaId)
+        : undefined;
+    if (typeof info?.email !== 'string' || info.email === '')
+        return null;
+    const name = typeof info.full_name === 'string' && info.full_name !== '' ? info.full_name : null;
+    return { email: info.email.toLowerCase(), ...(name && { name }) };
+}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { ChromeExtractor } from './connectors/ChromeExtractor.js';
+export { default as ChromeTransformer } from './connectors/ChromeTransformer.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,3 @@
+// Export extractors for plugin scanning
+export { ChromeExtractor } from './connectors/ChromeExtractor.js';
+export { default as ChromeTransformer } from './connectors/ChromeTransformer.js';

package/package.json

@@ -1,6 +1,78 @@
 {
   "name": "@chronicle.app/chrome",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.4.0",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist/**/*.js",
+    "dist/**/*.d.ts"
+  ],
+  "scripts": {
+    "build": "tsc -b tsconfig.lib.json",
+    "typecheck": "tsc -p tsconfig.json",
+    "lint": "eslint src --ext .ts,.js",
+    "test": "node --test src/*.test.js",
+    "shapes": "node src/shapes.test.js --update"
+  },
+  "keywords": [],
+  "author": "Andrew Louis",
+  "license": "MIT",
+  "type": "module",
+  "description": "Chronicle Chrome browsing history plugin",
+  "devDependencies": {
+    "@chronicle.app/etl": "0.4.0",
+    "@chronicle.app/schema": "0.4.0",
+    "@chronicle.app/tsconfig": "0.4.0",
+    "@types/node": "^22.10.1",
+    "typescript": "^5.7.2"
+  },
+  "homepage": "https://chronicle.app",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/chronicle-app/chronicle.git",
+    "directory": "plugins/chrome"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "dependencies": {
+    "@chronicle.app/etl-sqlite": "0.4.0",
+    "@chronicle.app/google": "0.4.0",
+    "zod": "^3.24.1"
+  },
+  "peerDependencies": {
+    "@chronicle.app/etl": ">=0.1.0 <1.0.0",
+    "@chronicle.app/schema": ">=0.1.0 <1.0.0"
+  },
+  "engines": {
+    "node": ">=22.13.0"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "chronicle": {
+    "plugin": true,
+    "sources": {
+      "chrome": {
+        "strategies": {
+          "app-db": {
+            "delivery": "local",
+            "recordTypes": [
+              "views"
+            ],
+            "default": true
+          }
+        },
+        "platforms": [
+          "darwin",
+          "linux",
+          "win32"
+        ]
+      }
+    }
+  }
+}