openplexer 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Kimaki
+
+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/dist/acp-client.d.ts

@@ -0,0 +1,13 @@
+import { ClientSideConnection, type SessionInfo } from '@agentclientprotocol/sdk';
+export type AcpConnection = {
+    connection: ClientSideConnection;
+    client: 'opencode' | 'claude';
+    kill: () => void;
+};
+export declare function connectAcp({ client, }: {
+    client: 'opencode' | 'claude';
+}): Promise<AcpConnection>;
+export declare function listAllSessions({ connection, }: {
+    connection: ClientSideConnection;
+}): Promise<SessionInfo[]>;
+//# sourceMappingURL=acp-client.d.ts.map

package/dist/acp-client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"acp-client.d.ts","sourceRoot":"","sources":["../src/acp-client.ts"],"names":[],"mappings":"AAKA,OAAO,EACL,oBAAoB,EAIpB,KAAK,WAAW,EACjB,MAAM,0BAA0B,CAAA;AAkDjC,MAAM,MAAM,aAAa,GAAG;IAC1B,UAAU,EAAE,oBAAoB,CAAA;IAChC,MAAM,EAAE,UAAU,GAAG,QAAQ,CAAA;IAC7B,IAAI,EAAE,MAAM,IAAI,CAAA;CACjB,CAAA;AAED,wBAAsB,UAAU,CAAC,EAC/B,MAAM,GACP,EAAE;IACD,MAAM,EAAE,UAAU,GAAG,QAAQ,CAAA;CAC9B,GAAG,OAAO,CAAC,aAAa,CAAC,CA6BzB;AAED,wBAAsB,eAAe,CAAC,EACpC,UAAU,GACX,EAAE;IACD,UAAU,EAAE,oBAAoB,CAAA;CACjC,GAAG,OAAO,CAAC,WAAW,EAAE,CAAC,CAiBzB"}

package/dist/acp-client.js

@@ -0,0 +1,88 @@
+// Spawn an ACP agent (opencode or claude) as a child process and connect
+// as a client via stdio. Uses @agentclientprotocol/sdk for the protocol.
+import { spawn } from 'node:child_process';
+import { ClientSideConnection, ndJsonStream, } from '@agentclientprotocol/sdk';
+function nodeToWebWritable(nodeStream) {
+    return new WritableStream({
+        write(chunk) {
+            return new Promise((resolve, reject) => {
+                nodeStream.write(Buffer.from(chunk), (err) => {
+                    if (err) {
+                        reject(err);
+                    }
+                    else {
+                        resolve();
+                    }
+                });
+            });
+        },
+    });
+}
+function nodeToWebReadable(nodeStream) {
+    return new ReadableStream({
+        start(controller) {
+            nodeStream.on('data', (chunk) => {
+                controller.enqueue(new Uint8Array(chunk));
+            });
+            nodeStream.on('end', () => {
+                controller.close();
+            });
+            nodeStream.on('error', (err) => {
+                controller.error(err);
+            });
+        },
+    });
+}
+// Minimal Client implementation — we only need session listing,
+// not file ops or permissions. requestPermission and sessionUpdate
+// are required by the Client interface.
+class MinimalClient {
+    async requestPermission() {
+        return { outcome: { outcome: 'cancelled' } };
+    }
+    async sessionUpdate() { }
+    async readTextFile() {
+        return { content: '' };
+    }
+    async writeTextFile() {
+        return {};
+    }
+}
+export async function connectAcp({ client, }) {
+    const cmd = client === 'opencode' ? 'opencode' : 'claude';
+    const args = ['acp'];
+    const child = spawn(cmd, args, {
+        stdio: ['pipe', 'pipe', 'inherit'],
+    });
+    const stream = ndJsonStream(nodeToWebWritable(child.stdin), nodeToWebReadable(child.stdout));
+    const connection = new ClientSideConnection((_agent) => {
+        return new MinimalClient();
+    }, stream);
+    await connection.initialize({
+        protocolVersion: 1,
+        clientCapabilities: {},
+    });
+    return {
+        connection,
+        client,
+        kill: () => {
+            child.kill();
+        },
+    };
+}
+export async function listAllSessions({ connection, }) {
+    const sessions = [];
+    let cursor;
+    // Paginate through all sessions
+    while (true) {
+        const response = await connection.listSessions({
+            ...(cursor ? { cursor } : {}),
+        });
+        sessions.push(...response.sessions);
+        if (!response.nextCursor) {
+            break;
+        }
+        cursor = response.nextCursor;
+    }
+    return sessions;
+}

package/dist/cli.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=cli.d.ts.map

package/dist/cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":""}

package/dist/cli.js

@@ -0,0 +1,308 @@
+#!/usr/bin/env node
+// openplexer CLI entrypoint.
+// Syncs ACP sessions (from OpenCode or Claude Code) to Notion board databases.
+// Uses goke for CLI parsing and clack for interactive prompts.
+import { goke } from 'goke';
+import { intro, outro, note, cancel, isCancel, confirm, log, multiselect, select, spinner, } from '@clack/prompts';
+import crypto from 'node:crypto';
+import path from 'node:path';
+import { exec } from 'node:child_process';
+import { readConfig, writeConfig } from "./config.js";
+import { connectAcp, listAllSessions } from "./acp-client.js";
+import { getRepoInfo } from "./git.js";
+import { createNotionClient, createBoardDatabase, getRootPages } from "./notion.js";
+import { evictExistingInstance, getLockPort, startLockServer } from "./lock.js";
+import { startSyncLoop } from "./sync.js";
+import { enableStartupService, disableStartupService, isStartupServiceEnabled, getServiceLocationDescription, } from "./startup-service.js";
+const OPENPLEXER_URL = 'https://openplexer.com';
+process.title = 'openplexer';
+const cli = goke('openplexer');
+// Default command: start sync if boards exist, otherwise run connect wizard
+cli
+    .command('', 'Sync coding sessions to Notion boards')
+    .action(async () => {
+    const config = readConfig();
+    if (!config || config.boards.length === 0) {
+        await connectFlow();
+        return;
+    }
+    await startDaemon(config);
+});
+// Connect command: add a new board
+cli.command('connect', 'Connect a new Notion board').action(async () => {
+    await connectFlow();
+});
+// Status command: show current sync state
+cli.command('status', 'Show sync state').action(async () => {
+    const config = readConfig();
+    if (!config || config.boards.length === 0) {
+        console.log('No boards configured. Run `openplexer connect` to add one.');
+        return;
+    }
+    console.log(`Clients: ${config.clients.join(', ')}`);
+    console.log(`Boards: ${config.boards.length}`);
+    config.boards.forEach((board, i) => {
+        console.log(`  ${i + 1}. ${board.notionWorkspaceName} — ${board.trackedRepos.length} repos, ${Object.keys(board.syncedSessions).length} synced sessions`);
+    });
+});
+// Stop command: kill running daemon via lock port
+cli.command('stop', 'Stop the running openplexer daemon').action(async () => {
+    const port = getLockPort();
+    const probe = await fetch(`http://127.0.0.1:${port}/health`, {
+        signal: AbortSignal.timeout(1000),
+    }).catch(() => {
+        return undefined;
+    });
+    if (!probe) {
+        console.log('No running daemon found.');
+        return;
+    }
+    const body = (await probe.json().catch(() => ({})));
+    if (body.pid) {
+        process.kill(body.pid, 'SIGTERM');
+        console.log(`Stopped daemon (PID ${body.pid})`);
+    }
+});
+// Boards command: list boards
+cli.command('boards', 'List configured boards').action(async () => {
+    const config = readConfig();
+    if (!config || config.boards.length === 0) {
+        console.log('No boards configured.');
+        return;
+    }
+    config.boards.forEach((board, i) => {
+        console.log(`${i + 1}. ${board.notionWorkspaceName}`);
+        console.log(`   Page: https://notion.so/${board.notionPageId.replace(/-/g, '')}`);
+        console.log(`   Repos: ${board.trackedRepos.join(', ') || '(all)'}`);
+        console.log(`   Synced: ${Object.keys(board.syncedSessions).length} sessions`);
+    });
+});
+// Startup command: manage startup registration
+cli.command('startup', 'Show startup registration status').action(async () => {
+    const enabled = await isStartupServiceEnabled();
+    if (enabled) {
+        console.log(`Registered: ${getServiceLocationDescription()}`);
+    }
+    else {
+        console.log('Not registered to run on login.');
+    }
+});
+cli
+    .command('startup enable', 'Register openplexer to run on login')
+    .action(async () => {
+    const openplexerBin = path.resolve(process.argv[1]);
+    await enableStartupService({ command: process.execPath, args: [openplexerBin] });
+    console.log(`Registered at ${getServiceLocationDescription()}`);
+});
+cli
+    .command('startup disable', 'Unregister openplexer from login')
+    .action(async () => {
+    await disableStartupService();
+    console.log('Unregistered from login startup.');
+});
+cli.parse();
+// --- Connect wizard ---
+async function connectFlow() {
+    intro('openplexer — connect a Notion board');
+    const config = readConfig() || { clients: [], boards: [] };
+    // Step 1: Choose ACP clients (only on first run)
+    if (config.clients.length === 0) {
+        const clientChoice = await multiselect({
+            message: 'Which coding agents do you use?',
+            options: [
+                { value: 'opencode', label: 'OpenCode' },
+                { value: 'claude', label: 'Claude Code' },
+            ],
+            required: true,
+        });
+        if (isCancel(clientChoice)) {
+            cancel('Setup cancelled');
+            process.exit(0);
+        }
+        config.clients = clientChoice;
+    }
+    // Step 2: Spawn ACP for each client and discover projects
+    const s = spinner();
+    const clientLabel = config.clients.join(' + ');
+    s.start(`Connecting to ${clientLabel}...`);
+    let repoSlugs = [];
+    const connectedClients = [];
+    for (const client of config.clients) {
+        try {
+            const acp = await connectAcp({ client });
+            const sessions = await listAllSessions({ connection: acp.connection });
+            // Extract unique repos from session cwds
+            const cwds = [...new Set(sessions.map((sess) => sess.cwd).filter(Boolean))];
+            const repoInfos = await Promise.all(cwds.map((cwd) => getRepoInfo({ cwd })));
+            repoSlugs.push(...repoInfos.filter(Boolean).map((r) => r.slug));
+            acp.kill();
+            connectedClients.push(client);
+            log.info(`${client}: ${sessions.length} sessions`);
+        }
+        catch {
+            log.warn(`Could not connect to ${client}. Make sure "${client}" is installed and in PATH.`);
+        }
+    }
+    repoSlugs = [...new Set(repoSlugs)];
+    s.stop(`Found ${repoSlugs.length} repos from ${connectedClients.join(' + ')}`);
+    if (connectedClients.length === 0) {
+        log.error('Could not connect to any ACP agent.');
+        process.exit(1);
+    }
+    // Step 3: Select repos to track
+    let trackedRepos = [];
+    if (repoSlugs.length > 0) {
+        note('Select specific repos if you plan to collaborate.\nThis avoids showing personal projects on the shared board.', 'Repo selection');
+        const repoChoice = await multiselect({
+            message: 'Which repos to track?',
+            options: [
+                { value: '*', label: '* All repos', hint: 'sync every repo with a git remote' },
+                ...repoSlugs.map((slug) => ({
+                    value: slug,
+                    label: slug,
+                })),
+            ],
+            required: false,
+        });
+        if (isCancel(repoChoice)) {
+            cancel('Setup cancelled');
+            process.exit(0);
+        }
+        trackedRepos = repoChoice.includes('*') ? [] : repoChoice;
+    }
+    else {
+        log.warn('No git repos found in sessions. All future sessions will be tracked.');
+    }
+    // Step 4: Notion OAuth
+    const state = crypto.randomBytes(16).toString('hex');
+    const authUrl = `${OPENPLEXER_URL}/auth/notion?state=${state}`;
+    note(`Opening browser to connect Notion.\nAuthorize the integration and select a page to share.\n\n${authUrl}`, 'Notion');
+    // Open browser
+    const openCmd = process.platform === 'darwin' ? 'open' : process.platform === 'win32' ? 'start' : 'xdg-open';
+    exec(`${openCmd} "${authUrl}"`);
+    s.start('Waiting for Notion authorization...');
+    let authResult;
+    const maxAttempts = 150; // 5 minutes at 2s intervals
+    for (let i = 0; i < maxAttempts; i++) {
+        await new Promise((resolve) => {
+            setTimeout(resolve, 2000);
+        });
+        const resp = await fetch(`${OPENPLEXER_URL}/auth/status?state=${state}`, {
+            signal: AbortSignal.timeout(3000),
+        }).catch(() => {
+            return undefined;
+        });
+        if (resp?.ok) {
+            authResult = (await resp.json());
+            break;
+        }
+    }
+    if (!authResult) {
+        s.stop('Timed out waiting for Notion authorization');
+        process.exit(1);
+    }
+    s.stop(`Connected to ${authResult.workspaceName}`);
+    // Step 5: Select Notion page from root pages
+    const notion = createNotionClient({ token: authResult.accessToken });
+    s.start('Fetching Notion pages...');
+    const rootPages = await getRootPages({ notion });
+    s.stop(`Found ${rootPages.length} root pages`);
+    if (rootPages.length === 0) {
+        log.error('No root pages found in your Notion workspace. Create a page first.');
+        process.exit(1);
+    }
+    // Filter out pages already used by other boards
+    const usedPageIds = new Set(config.boards.map((b) => b.notionPageId));
+    const availablePages = rootPages.filter((p) => !usedPageIds.has(p.id));
+    if (availablePages.length === 0) {
+        log.error('All root pages are already connected to boards.');
+        process.exit(1);
+    }
+    const pageId = await (async () => {
+        if (availablePages.length === 1) {
+            log.info(`Auto-selected page: ${availablePages[0].icon} ${availablePages[0].title}`);
+            return availablePages[0].id;
+        }
+        const pageChoice = await select({
+            message: 'Which Notion page should hold the board?',
+            options: availablePages.map((p) => ({
+                value: p.id,
+                label: `${p.icon} ${p.title}`.trim(),
+                hint: usedPageIds.has(p.id) ? 'already used' : undefined,
+            })),
+        });
+        if (isCancel(pageChoice)) {
+            cancel('Setup cancelled');
+            process.exit(0);
+        }
+        return pageChoice;
+    })();
+    // Step 6: Create database
+    s.start('Creating board database...');
+    const { databaseId } = await createBoardDatabase({ notion, pageId });
+    s.stop('Board database created');
+    log.success('Open the database in Notion and click "+ Add a view" → Board, grouped by Status.');
+    // Step 7: Save to config
+    const board = {
+        notionToken: authResult.accessToken,
+        notionUserId: authResult.notionUserId || '',
+        notionUserName: authResult.notionUserName || '',
+        notionWorkspaceId: authResult.workspaceId,
+        notionWorkspaceName: authResult.workspaceName,
+        notionPageId: pageId,
+        notionDatabaseId: databaseId,
+        trackedRepos,
+        syncedSessions: {},
+        connectedAt: new Date().toISOString(),
+    };
+    config.boards.push(board);
+    writeConfig(config);
+    // Resolve absolute path to the CLI script so startup service and
+    // detached spawn work regardless of cwd at login/invocation time.
+    const openplexerBin = path.resolve(process.argv[1]);
+    // Step 8: Offer startup registration
+    const alreadyEnabled = await isStartupServiceEnabled();
+    if (!alreadyEnabled) {
+        const registerStartup = await confirm({
+            message: 'Register openplexer to run on login?',
+        });
+        if (!isCancel(registerStartup) && registerStartup) {
+            await enableStartupService({ command: process.execPath, args: [openplexerBin] });
+            log.success(`Registered at ${getServiceLocationDescription()}`);
+        }
+    }
+    else {
+        log.info(`Already registered at ${getServiceLocationDescription()}`);
+    }
+    // Step 9: Spawn daemon in background so syncing starts immediately
+    const { spawn: spawnProcess } = await import('node:child_process');
+    const child = spawnProcess(process.execPath, [openplexerBin], {
+        detached: true,
+        stdio: 'ignore',
+    });
+    child.unref();
+    outro('Board connected! Sync daemon started in background.');
+}
+// --- Daemon ---
+async function startDaemon(config) {
+    const port = getLockPort();
+    await evictExistingInstance({ port });
+    startLockServer({ port });
+    console.log(`openplexer daemon started (PID ${process.pid}, port ${port})`);
+    const connections = [];
+    for (const client of config.clients) {
+        try {
+            const acp = await connectAcp({ client });
+            connections.push(acp);
+            console.log(`Connected to ${client} via ACP`);
+        }
+        catch {
+            console.error(`Failed to connect to ${client}, skipping`);
+        }
+    }
+    if (connections.length === 0) {
+        console.error('Could not connect to any ACP agent.');
+        process.exit(1);
+    }
+    await startSyncLoop({ config, acpConnections: connections });
+}

package/dist/config.d.ts

@@ -0,0 +1,34 @@
+export type OpenplexerBoard = {
+    /** Notion OAuth access token */
+    notionToken: string;
+    /** Notion user ID of this machine's user */
+    notionUserId: string;
+    /** Notion user name */
+    notionUserName: string;
+    /** Notion workspace ID */
+    notionWorkspaceId: string;
+    /** Notion workspace name */
+    notionWorkspaceName: string;
+    /** Notion page ID where database was created */
+    notionPageId: string;
+    /** Notion database ID (created by CLI) */
+    notionDatabaseId: string;
+    /** Git repo URLs to track (e.g. ["owner/repo1", "owner/repo2"]) */
+    trackedRepos: string[];
+    /** Map of ACP session ID → Notion page ID (already synced) */
+    syncedSessions: Record<string, string>;
+    /** ISO timestamp of when this board was connected. Only sessions
+     *  created or last updated after this time are synced. */
+    connectedAt: string;
+};
+export type AcpClient = 'opencode' | 'claude';
+export type OpenplexerConfig = {
+    /** ACP clients to connect to (user may use both opencode and claude) */
+    clients: AcpClient[];
+    /** Multiple boards this CLI syncs to */
+    boards: OpenplexerBoard[];
+};
+export declare function getConfigDir(): string;
+export declare function readConfig(): OpenplexerConfig | undefined;
+export declare function writeConfig(config: OpenplexerConfig): void;
+//# sourceMappingURL=config.d.ts.map

package/dist/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AAQA,MAAM,MAAM,eAAe,GAAG;IAC5B,gCAAgC;IAChC,WAAW,EAAE,MAAM,CAAA;IACnB,4CAA4C;IAC5C,YAAY,EAAE,MAAM,CAAA;IACpB,uBAAuB;IACvB,cAAc,EAAE,MAAM,CAAA;IACtB,0BAA0B;IAC1B,iBAAiB,EAAE,MAAM,CAAA;IACzB,4BAA4B;IAC5B,mBAAmB,EAAE,MAAM,CAAA;IAC3B,gDAAgD;IAChD,YAAY,EAAE,MAAM,CAAA;IACpB,0CAA0C;IAC1C,gBAAgB,EAAE,MAAM,CAAA;IACxB,mEAAmE;IACnE,YAAY,EAAE,MAAM,EAAE,CAAA;IACtB,8DAA8D;IAC9D,cAAc,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IACtC;8DAC0D;IAC1D,WAAW,EAAE,MAAM,CAAA;CACpB,CAAA;AAED,MAAM,MAAM,SAAS,GAAG,UAAU,GAAG,QAAQ,CAAA;AAE7C,MAAM,MAAM,gBAAgB,GAAG;IAC7B,wEAAwE;IACxE,OAAO,EAAE,SAAS,EAAE,CAAA;IACpB,wCAAwC;IACxC,MAAM,EAAE,eAAe,EAAE,CAAA;CAC1B,CAAA;AAKD,wBAAgB,YAAY,IAAI,MAAM,CAErC;AAED,wBAAgB,UAAU,IAAI,gBAAgB,GAAG,SAAS,CAOzD;AAED,wBAAgB,WAAW,CAAC,MAAM,EAAE,gBAAgB,GAAG,IAAI,CAK1D"}

package/dist/config.js

@@ -0,0 +1,26 @@
+// Typed config for openplexer, stored at ~/.openplexer/config.json.
+// Supports multiple boards — each board is a separate Notion database
+// that this CLI syncs ACP sessions to.
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+const CONFIG_DIR = path.join(os.homedir(), '.openplexer');
+const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
+export function getConfigDir() {
+    return CONFIG_DIR;
+}
+export function readConfig() {
+    try {
+        const raw = fs.readFileSync(CONFIG_FILE, 'utf-8');
+        return JSON.parse(raw);
+    }
+    catch {
+        return undefined;
+    }
+}
+export function writeConfig(config) {
+    fs.mkdirSync(CONFIG_DIR, { recursive: true });
+    const tmpFile = CONFIG_FILE + '.tmp';
+    fs.writeFileSync(tmpFile, JSON.stringify(config, null, 2));
+    fs.renameSync(tmpFile, CONFIG_FILE);
+}

package/dist/env.d.ts

@@ -0,0 +1,6 @@
+export type Env = {
+    OPENPLEXER_KV: KVNamespace;
+    NOTION_CLIENT_ID: string;
+    NOTION_CLIENT_SECRET: string;
+};
+//# sourceMappingURL=env.d.ts.map

package/dist/env.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"env.d.ts","sourceRoot":"","sources":["../src/env.ts"],"names":[],"mappings":"AAIA,MAAM,MAAM,GAAG,GAAG;IAChB,aAAa,EAAE,WAAW,CAAA;IAC1B,gBAAgB,EAAE,MAAM,CAAA;IACxB,oBAAoB,EAAE,MAAM,CAAA;CAC7B,CAAA"}

package/dist/env.js

@@ -0,0 +1,4 @@
+// Typed environment variables for the Cloudflare Worker.
+// NOTION_CLIENT_ID and NOTION_CLIENT_SECRET are the openplexer Notion
+// integration's OAuth2 credentials, used to exchange auth codes for tokens.
+export {};

package/dist/git.d.ts

@@ -0,0 +1,14 @@
+export type RepoInfo = {
+    owner: string;
+    repo: string;
+    /** e.g. "owner/repo" */
+    slug: string;
+    /** Full GitHub URL */
+    url: string;
+    /** Current branch name */
+    branch: string;
+};
+export declare function getRepoInfo({ cwd }: {
+    cwd: string;
+}): Promise<RepoInfo | undefined>;
+//# sourceMappingURL=git.d.ts.map

package/dist/git.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"git.d.ts","sourceRoot":"","sources":["../src/git.ts"],"names":[],"mappings":"AAKA,MAAM,MAAM,QAAQ,GAAG;IACrB,KAAK,EAAE,MAAM,CAAA;IACb,IAAI,EAAE,MAAM,CAAA;IACZ,wBAAwB;IACxB,IAAI,EAAE,MAAM,CAAA;IACZ,sBAAsB;IACtB,GAAG,EAAE,MAAM,CAAA;IACX,0BAA0B;IAC1B,MAAM,EAAE,MAAM,CAAA;CACf,CAAA;AAED,wBAAsB,WAAW,CAAC,EAAE,GAAG,EAAE,EAAE;IAAE,GAAG,EAAE,MAAM,CAAA;CAAE,GAAG,OAAO,CAAC,QAAQ,GAAG,SAAS,CAAC,CAyBzF"}

package/dist/git.js

@@ -0,0 +1,60 @@
+// Extract git repo info from session cwd paths.
+// Parses the remote origin URL to get owner/repo.
+import { execFile } from 'node:child_process';
+export async function getRepoInfo({ cwd }) {
+    const remoteUrl = await execAsync('git', ['-C', cwd, 'remote', 'get-url', 'origin']).catch(() => {
+        return undefined;
+    });
+    if (!remoteUrl) {
+        return undefined;
+    }
+    const parsed = parseGitRemoteUrl(remoteUrl.trim());
+    if (!parsed) {
+        return undefined;
+    }
+    const branch = await execAsync('git', ['-C', cwd, 'rev-parse', '--abbrev-ref', 'HEAD']).catch(() => {
+        return 'main';
+    });
+    return {
+        ...parsed,
+        branch: branch.trim(),
+    };
+}
+function parseGitRemoteUrl(url) {
+    // SSH: git@github.com:owner/repo.git
+    const sshMatch = url.match(/git@github\.com:([^/]+)\/([^/.]+)/);
+    if (sshMatch) {
+        const owner = sshMatch[1];
+        const repo = sshMatch[2];
+        return {
+            owner,
+            repo,
+            slug: `${owner}/${repo}`,
+            url: `https://github.com/${owner}/${repo}`,
+        };
+    }
+    // HTTPS: https://github.com/owner/repo.git
+    const httpsMatch = url.match(/github\.com\/([^/]+)\/([^/.]+)/);
+    if (httpsMatch) {
+        const owner = httpsMatch[1];
+        const repo = httpsMatch[2];
+        return {
+            owner,
+            repo,
+            slug: `${owner}/${repo}`,
+            url: `https://github.com/${owner}/${repo}`,
+        };
+    }
+    return undefined;
+}
+function execAsync(cmd, args) {
+    return new Promise((resolve, reject) => {
+        execFile(cmd, args, { timeout: 5000 }, (error, stdout) => {
+            if (error) {
+                reject(error);
+                return;
+            }
+            resolve(stdout);
+        });
+    });
+}

package/dist/lock.d.ts

@@ -0,0 +1,9 @@
+import http from 'node:http';
+export declare function getLockPort(): number;
+export declare function evictExistingInstance({ port }: {
+    port: number;
+}): Promise<void>;
+export declare function startLockServer({ port }: {
+    port: number;
+}): http.Server;
+//# sourceMappingURL=lock.d.ts.map

package/dist/lock.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lock.d.ts","sourceRoot":"","sources":["../src/lock.ts"],"names":[],"mappings":"AAGA,OAAO,IAAI,MAAM,WAAW,CAAA;AAI5B,wBAAgB,WAAW,IAAI,MAAM,CASpC;AAED,wBAAsB,qBAAqB,CAAC,EAAE,IAAI,EAAE,EAAE;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CA+BrF;AAED,wBAAgB,eAAe,CAAC,EAAE,IAAI,EAAE,EAAE;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAAC,MAAM,CAavE"}