openplexer 0.1.0

package/dist/lock.js

@@ -0,0 +1,55 @@
+// Single-instance enforcement via lock port.
+// Same pattern as kimaki's hrana-server.ts: probe /health, SIGTERM, SIGKILL.
+import http from 'node:http';
+const DEFAULT_LOCK_PORT = 29990;
+export function getLockPort() {
+    const envPort = process.env['OPENPLEXER_LOCK_PORT'];
+    if (envPort) {
+        const parsed = Number.parseInt(envPort, 10);
+        if (Number.isInteger(parsed) && parsed >= 1 && parsed <= 65535) {
+            return parsed;
+        }
+    }
+    return DEFAULT_LOCK_PORT;
+}
+export async function evictExistingInstance({ port }) {
+    const url = `http://127.0.0.1:${port}/health`;
+    const probe = await fetch(url, { signal: AbortSignal.timeout(1000) }).catch(() => {
+        return undefined;
+    });
+    if (!probe) {
+        return;
+    }
+    const body = (await probe.json().catch(() => ({})));
+    const targetPid = body.pid;
+    if (!targetPid || targetPid === process.pid) {
+        return;
+    }
+    process.kill(targetPid, 'SIGTERM');
+    await new Promise((resolve) => {
+        setTimeout(resolve, 1000);
+    });
+    const secondProbe = await fetch(url, { signal: AbortSignal.timeout(500) }).catch(() => {
+        return undefined;
+    });
+    if (!secondProbe) {
+        return;
+    }
+    process.kill(targetPid, 'SIGKILL');
+    await new Promise((resolve) => {
+        setTimeout(resolve, 1000);
+    });
+}
+export function startLockServer({ port }) {
+    const server = http.createServer((req, res) => {
+        if (req.url === '/health') {
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ pid: process.pid, status: 'ok' }));
+            return;
+        }
+        res.writeHead(404);
+        res.end();
+    });
+    server.listen(port, '127.0.0.1');
+    return server;
+}

package/dist/notion.d.ts

@@ -0,0 +1,59 @@
+import { Client } from '@notionhq/client';
+export declare const STATUS_OPTIONS: ({
+    name: string;
+    color: "default";
+} | {
+    name: string;
+    color: "blue";
+} | {
+    name: string;
+    color: "green";
+} | {
+    name: string;
+    color: "red";
+} | {
+    name: string;
+    color: "gray";
+})[];
+export type CreateDatabaseResult = {
+    databaseId: string;
+};
+export declare function createNotionClient({ token }: {
+    token: string;
+}): Client;
+export type RootPage = {
+    id: string;
+    title: string;
+    url: string;
+    icon: string;
+};
+export declare function getRootPages({ notion }: {
+    notion: Client;
+}): Promise<RootPage[]>;
+export declare function createBoardDatabase({ notion, pageId, }: {
+    notion: Client;
+    pageId: string;
+}): Promise<CreateDatabaseResult>;
+export declare function createSessionPage({ notion, databaseId, title, sessionId, status, repoSlug, branchUrl, shareUrl, resumeCommand, assigneeId, folder, discordUrl, updatedAt, }: {
+    notion: Client;
+    databaseId: string;
+    title: string;
+    sessionId: string;
+    status: string;
+    repoSlug: string;
+    branchUrl?: string;
+    shareUrl?: string;
+    resumeCommand: string;
+    assigneeId?: string;
+    folder: string;
+    discordUrl?: string;
+    updatedAt?: string;
+}): Promise<string>;
+export declare function updateSessionPage({ notion, pageId, title, updatedAt, }: {
+    notion: Client;
+    pageId: string;
+    title?: string;
+    updatedAt?: string;
+}): Promise<void>;
+export declare function rateLimitedCall<T>(fn: () => Promise<T>): Promise<T>;
+//# sourceMappingURL=notion.d.ts.map

package/dist/notion.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"notion.d.ts","sourceRoot":"","sources":["../src/notion.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAA;AAEzC,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;IAM1B,CAAA;AAED,MAAM,MAAM,oBAAoB,GAAG;IACjC,UAAU,EAAE,MAAM,CAAA;CACnB,CAAA;AAED,wBAAgB,kBAAkB,CAAC,EAAE,KAAK,EAAE,EAAE;IAAE,KAAK,EAAE,MAAM,CAAA;CAAE,GAAG,MAAM,CAEvE;AAED,MAAM,MAAM,QAAQ,GAAG;IACrB,EAAE,EAAE,MAAM,CAAA;IACV,KAAK,EAAE,MAAM,CAAA;IACb,GAAG,EAAE,MAAM,CAAA;IACX,IAAI,EAAE,MAAM,CAAA;CACb,CAAA;AAMD,wBAAsB,YAAY,CAAC,EAAE,MAAM,EAAE,EAAE;IAAE,MAAM,EAAE,MAAM,CAAA;CAAE,GAAG,OAAO,CAAC,QAAQ,EAAE,CAAC,CA6CtF;AAED,wBAAsB,mBAAmB,CAAC,EACxC,MAAM,EACN,MAAM,GACP,EAAE;IACD,MAAM,EAAE,MAAM,CAAA;IACd,MAAM,EAAE,MAAM,CAAA;CACf,GAAG,OAAO,CAAC,oBAAoB,CAAC,CAuChC;AAED,wBAAsB,iBAAiB,CAAC,EACtC,MAAM,EACN,UAAU,EACV,KAAK,EACL,SAAS,EACT,MAAM,EACN,QAAQ,EACR,SAAS,EACT,QAAQ,EACR,aAAa,EACb,UAAU,EACV,MAAM,EACN,UAAU,EACV,SAAS,GACV,EAAE;IACD,MAAM,EAAE,MAAM,CAAA;IACd,UAAU,EAAE,MAAM,CAAA;IAClB,KAAK,EAAE,MAAM,CAAA;IACb,SAAS,EAAE,MAAM,CAAA;IACjB,MAAM,EAAE,MAAM,CAAA;IACd,QAAQ,EAAE,MAAM,CAAA;IAChB,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,aAAa,EAAE,MAAM,CAAA;IACrB,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,MAAM,EAAE,MAAM,CAAA;IACd,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,SAAS,CAAC,EAAE,MAAM,CAAA;CACnB,GAAG,OAAO,CAAC,MAAM,CAAC,CAgClB;AAED,wBAAsB,iBAAiB,CAAC,EACtC,MAAM,EACN,MAAM,EACN,KAAK,EACL,SAAS,GACV,EAAE;IACD,MAAM,EAAE,MAAM,CAAA;IACd,MAAM,EAAE,MAAM,CAAA;IACd,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,SAAS,CAAC,EAAE,MAAM,CAAA;CACnB,GAAG,OAAO,CAAC,IAAI,CAAC,CAkBhB;AAMD,wBAAsB,eAAe,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAUzE"}

package/dist/notion.js

@@ -0,0 +1,154 @@
+// Notion API wrapper for openplexer.
+// Creates board databases, creates/updates session pages.
+import { Client } from '@notionhq/client';
+export const STATUS_OPTIONS = [
+    { name: 'Not Started', color: 'default' },
+    { name: 'In Progress', color: 'blue' },
+    { name: 'Done', color: 'green' },
+    { name: 'Needs Attention', color: 'red' },
+    { name: 'Ignored', color: 'gray' },
+];
+export function createNotionClient({ token }) {
+    return new Client({ auth: token });
+}
+// Get all accessible pages using notion.search. With OAuth integrations,
+// only pages the user explicitly shared during consent are returned.
+// We don't filter by parent.type === 'workspace' because shared pages
+// can be nested under other pages.
+export async function getRootPages({ notion }) {
+    const pages = [];
+    let startCursor;
+    for (let page = 0; page < 3; page++) {
+        const res = await notion.search({
+            filter: { property: 'object', value: 'page' },
+            page_size: 100,
+            sort: { direction: 'descending', timestamp: 'last_edited_time' },
+            ...(startCursor ? { start_cursor: startCursor } : {}),
+        });
+        for (const result of res.results) {
+            if (!('parent' in result) || !('properties' in result)) {
+                continue;
+            }
+            const titleProp = Object.values(result.properties).find((p) => p.type === 'title');
+            const title = (() => {
+                if (!titleProp || titleProp.type !== 'title') {
+                    return '';
+                }
+                return titleProp.title.map((t) => t.plain_text).join('');
+            })();
+            const icon = (() => {
+                if (!result.icon) {
+                    return '';
+                }
+                if (result.icon.type === 'emoji') {
+                    return result.icon.emoji;
+                }
+                return '';
+            })();
+            pages.push({ id: result.id, title: title || result.url, url: result.url, icon });
+        }
+        if (!res.has_more || !res.next_cursor) {
+            break;
+        }
+        startCursor = res.next_cursor;
+    }
+    return pages;
+}
+export async function createBoardDatabase({ notion, pageId, }) {
+    const database = await notion.databases.create({
+        parent: { type: 'page_id', page_id: pageId },
+        title: [{ text: { content: 'openplexer - Coding Sessions' } }],
+        initial_data_source: {
+            properties: {
+                Name: { type: 'title', title: {} },
+                Status: {
+                    type: 'select',
+                    select: { options: STATUS_OPTIONS },
+                },
+                Repo: { type: 'select', select: { options: [] } },
+                Branch: { type: 'url', url: {} },
+                'Share URL': { type: 'url', url: {} },
+                Resume: { type: 'rich_text', rich_text: {} },
+                'Session ID': { type: 'rich_text', rich_text: {} },
+                Assignee: { type: 'people', people: {} },
+                Folder: { type: 'rich_text', rich_text: {} },
+                Discord: { type: 'url', url: {} },
+                Updated: { type: 'date', date: {} },
+            },
+        },
+    });
+    // Database is created with a default Table view. Create a Board view
+    // grouped by Status so sessions show as a kanban board.
+    const dataSourceId = 'data_sources' in database
+        ? database.data_sources?.[0]?.id
+        : undefined;
+    if (dataSourceId) {
+        await notion.views.create({
+            database_id: database.id,
+            data_source_id: dataSourceId,
+            name: 'Board',
+            type: 'board',
+        });
+    }
+    return { databaseId: database.id };
+}
+export async function createSessionPage({ notion, databaseId, title, sessionId, status, repoSlug, branchUrl, shareUrl, resumeCommand, assigneeId, folder, discordUrl, updatedAt, }) {
+    const properties = {
+        Name: { title: [{ text: { content: title } }] },
+        Status: { select: { name: status } },
+        'Session ID': { rich_text: [{ text: { content: sessionId } }] },
+        Repo: { select: { name: repoSlug } },
+        Resume: { rich_text: [{ text: { content: resumeCommand } }] },
+        Folder: { rich_text: [{ text: { content: folder } }] },
+    };
+    if (branchUrl) {
+        properties['Branch'] = { url: branchUrl };
+    }
+    if (shareUrl) {
+        properties['Share URL'] = { url: shareUrl };
+    }
+    if (assigneeId) {
+        properties['Assignee'] = { people: [{ id: assigneeId }] };
+    }
+    if (discordUrl) {
+        properties['Discord'] = { url: discordUrl };
+    }
+    if (updatedAt) {
+        properties['Updated'] = { date: { start: updatedAt } };
+    }
+    const page = await notion.pages.create({
+        parent: { database_id: databaseId },
+        properties: properties,
+    });
+    return page.id;
+}
+export async function updateSessionPage({ notion, pageId, title, updatedAt, }) {
+    const properties = {};
+    if (title) {
+        properties['Name'] = { title: [{ text: { content: title } }] };
+    }
+    if (updatedAt) {
+        properties['Updated'] = { date: { start: updatedAt } };
+    }
+    if (Object.keys(properties).length === 0) {
+        return;
+    }
+    await notion.pages.update({
+        page_id: pageId,
+        properties: properties,
+    });
+}
+// Rate-limited queue for Notion API calls (max 3/sec)
+const RATE_LIMIT_MS = 350;
+let lastCallTime = 0;
+export async function rateLimitedCall(fn) {
+    const now = Date.now();
+    const elapsed = now - lastCallTime;
+    if (elapsed < RATE_LIMIT_MS) {
+        await new Promise((resolve) => {
+            setTimeout(resolve, RATE_LIMIT_MS - elapsed);
+        });
+    }
+    lastCallTime = Date.now();
+    return fn();
+}

package/dist/startup-service.d.ts

@@ -0,0 +1,9 @@
+export type StartupServiceOptions = {
+    command: string;
+    args: string[];
+};
+export declare function enableStartupService({ command, args }: StartupServiceOptions): Promise<void>;
+export declare function disableStartupService(): Promise<void>;
+export declare function isStartupServiceEnabled(): Promise<boolean>;
+export declare function getServiceLocationDescription(): string;
+//# sourceMappingURL=startup-service.d.ts.map

package/dist/startup-service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"startup-service.d.ts","sourceRoot":"","sources":["../src/startup-service.ts"],"names":[],"mappings":"AAoFA,MAAM,MAAM,qBAAqB,GAAG;IAClC,OAAO,EAAE,MAAM,CAAA;IACf,IAAI,EAAE,MAAM,EAAE,CAAA;CACf,CAAA;AAED,wBAAsB,oBAAoB,CAAC,EAAE,OAAO,EAAE,IAAI,EAAE,EAAE,qBAAqB,GAAG,OAAO,CAAC,IAAI,CAAC,CAmClG;AAED,wBAAsB,qBAAqB,IAAI,OAAO,CAAC,IAAI,CAAC,CAe3D;AAED,wBAAsB,uBAAuB,IAAI,OAAO,CAAC,OAAO,CAAC,CAiBhE;AAED,wBAAgB,6BAA6B,IAAI,MAAM,CAYtD"}

package/dist/startup-service.js

@@ -0,0 +1,150 @@
+// Cross-platform startup service registration for openplexer daemon.
+// Adapted from kimaki's startup-service.ts (vendored from startup-run, MIT).
+//
+// macOS:   ~/Library/LaunchAgents/com.openplexer.plist  (launchd)
+// Linux:   ~/.config/autostart/openplexer.desktop       (XDG autostart)
+// Windows: HKCU\Software\Microsoft\Windows\CurrentVersion\Run  (registry)
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { exec as _exec, execFile as _execFile } from 'node:child_process';
+const SERVICE_NAME = 'com.openplexer';
+function execAsync(command) {
+    return new Promise((resolve, reject) => {
+        _exec(command, { timeout: 5000 }, (error, stdout, stderr) => {
+            if (error) {
+                reject(error);
+                return;
+            }
+            resolve({ stdout, stderr });
+        });
+    });
+}
+function getServiceFilePath() {
+    switch (process.platform) {
+        case 'darwin':
+            return path.join(os.homedir(), 'Library', 'LaunchAgents', `${SERVICE_NAME}.plist`);
+        case 'linux':
+            return path.join(os.homedir(), '.config', 'autostart', 'openplexer.desktop');
+        case 'win32':
+            return 'HKCU\\Software\\Microsoft\\Windows\\CurrentVersion\\Run\\openplexer';
+        default:
+            throw new Error(`Unsupported platform: ${process.platform}`);
+    }
+}
+function escapeXml(value) {
+    return value.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+}
+function shellEscape(value) {
+    if (/^[a-zA-Z0-9._/=-]+$/.test(value)) {
+        return value;
+    }
+    return `"${value.replace(/"/g, '\\"')}"`;
+}
+function buildMacOSPlist({ command, args }) {
+    const segments = [command, ...args];
+    return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>${SERVICE_NAME}</string>
+  <key>ProgramArguments</key>
+  <array>
+${segments.map((s) => `    <string>${escapeXml(s)}</string>`).join('\n')}
+  </array>
+  <key>RunAtLoad</key>
+  <true/>
+  <key>KeepAlive</key>
+  <false/>
+</dict>
+</plist>
+`;
+}
+function buildLinuxDesktop({ command, args }) {
+    const execLine = [command, ...args].map(shellEscape).join(' ');
+    return `[Desktop Entry]
+Type=Application
+Version=1.0
+Name=openplexer
+Comment=openplexer session sync daemon
+Exec=${execLine}
+StartupNotify=false
+Terminal=false
+`;
+}
+export async function enableStartupService({ command, args }) {
+    const platform = process.platform;
+    if (platform === 'darwin') {
+        const filePath = getServiceFilePath();
+        fs.mkdirSync(path.dirname(filePath), { recursive: true });
+        fs.writeFileSync(filePath, buildMacOSPlist({ command, args }));
+    }
+    else if (platform === 'linux') {
+        const filePath = getServiceFilePath();
+        fs.mkdirSync(path.dirname(filePath), { recursive: true });
+        fs.writeFileSync(filePath, buildLinuxDesktop({ command, args }));
+    }
+    else if (platform === 'win32') {
+        const execLine = [command, ...args]
+            .map((s) => {
+            return s.includes(' ') ? `"${s}"` : s;
+        })
+            .join(' ');
+        // Use execFile with args array to avoid shell-quoting issues
+        await new Promise((resolve, reject) => {
+            _execFile('reg', ['add', 'HKCU\\Software\\Microsoft\\Windows\\CurrentVersion\\Run', '/v', 'openplexer', '/t', 'REG_SZ', '/d', execLine, '/f'], { timeout: 5000 }, (error) => {
+                if (error) {
+                    reject(error);
+                }
+                else {
+                    resolve();
+                }
+            });
+        });
+    }
+    else {
+        throw new Error(`Unsupported platform: ${platform}`);
+    }
+}
+export async function disableStartupService() {
+    const platform = process.platform;
+    if (platform === 'darwin' || platform === 'linux') {
+        const filePath = getServiceFilePath();
+        if (fs.existsSync(filePath)) {
+            fs.unlinkSync(filePath);
+        }
+    }
+    else if (platform === 'win32') {
+        await execAsync(`reg delete "HKCU\\Software\\Microsoft\\Windows\\CurrentVersion\\Run" /v openplexer /f`).catch(() => { });
+    }
+    else {
+        throw new Error(`Unsupported platform: ${platform}`);
+    }
+}
+export async function isStartupServiceEnabled() {
+    const platform = process.platform;
+    if (platform === 'darwin' || platform === 'linux') {
+        return fs.existsSync(getServiceFilePath());
+    }
+    if (platform === 'win32') {
+        const result = await execAsync(`reg query "HKCU\\Software\\Microsoft\\Windows\\CurrentVersion\\Run" /v openplexer`).catch(() => {
+            return null;
+        });
+        return result !== null;
+    }
+    return false;
+}
+export function getServiceLocationDescription() {
+    const platform = process.platform;
+    if (platform === 'darwin') {
+        return `launchd: ${getServiceFilePath()}`;
+    }
+    if (platform === 'linux') {
+        return `XDG autostart: ${getServiceFilePath()}`;
+    }
+    if (platform === 'win32') {
+        return `registry: ${getServiceFilePath()}`;
+    }
+    return `unsupported platform: ${platform}`;
+}

package/dist/sync.d.ts

@@ -0,0 +1,7 @@
+import type { OpenplexerConfig } from './config.ts';
+import { type AcpConnection } from './acp-client.ts';
+export declare function startSyncLoop({ config, acpConnections, }: {
+    config: OpenplexerConfig;
+    acpConnections: AcpConnection[];
+}): Promise<void>;
+//# sourceMappingURL=sync.d.ts.map

package/dist/sync.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sync.d.ts","sourceRoot":"","sources":["../src/sync.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAmB,gBAAgB,EAAa,MAAM,aAAa,CAAA;AAE/E,OAAO,EAAmB,KAAK,aAAa,EAAE,MAAM,iBAAiB,CAAA;AAcrE,wBAAsB,aAAa,CAAC,EAClC,MAAM,EACN,cAAc,GACf,EAAE;IACD,MAAM,EAAE,gBAAgB,CAAA;IACxB,cAAc,EAAE,aAAa,EAAE,CAAA;CAChC,GAAG,OAAO,CAAC,IAAI,CAAC,CAgBhB"}

package/dist/sync.js

@@ -0,0 +1,139 @@
+// Core sync loop: polls ACP sessions and syncs them to Notion pages.
+// Runs every 5 seconds, creates new pages for untracked sessions,
+// updates existing ones when title/updatedAt changes.
+import { writeConfig } from "./config.js";
+import { listAllSessions } from "./acp-client.js";
+import { getRepoInfo } from "./git.js";
+import { createNotionClient, createSessionPage, updateSessionPage, rateLimitedCall, } from "./notion.js";
+import { execFile } from 'node:child_process';
+const SYNC_INTERVAL_MS = 5000;
+export async function startSyncLoop({ config, acpConnections, }) {
+    console.log(`Syncing ${config.boards.length} board(s) every ${SYNC_INTERVAL_MS / 1000}s`);
+    const tick = async () => {
+        try {
+            await syncOnce({ config, acpConnections });
+        }
+        catch (err) {
+            console.error('Sync error:', err);
+        }
+    };
+    // Initial sync
+    await tick();
+    // Then every 5 seconds
+    setInterval(tick, SYNC_INTERVAL_MS);
+}
+async function syncOnce({ config, acpConnections, }) {
+    // Collect sessions from all ACP connections, tagged with their source
+    const sessions = [];
+    const seenIds = new Set();
+    for (const acp of acpConnections) {
+        const clientSessions = await listAllSessions({ connection: acp.connection });
+        for (const session of clientSessions) {
+            if (!seenIds.has(session.sessionId)) {
+                seenIds.add(session.sessionId);
+                sessions.push({ ...session, source: acp.client });
+            }
+        }
+    }
+    for (const board of config.boards) {
+        await syncBoard({ board, sessions });
+    }
+    // Persist updated syncedSessions
+    writeConfig(config);
+}
+async function syncBoard({ board, sessions, }) {
+    const notion = createNotionClient({ token: board.notionToken });
+    // Filter sessions to tracked repos
+    const filteredSessions = [];
+    const connectedAtMs = new Date(board.connectedAt).getTime();
+    for (const session of sessions) {
+        if (!session.cwd) {
+            continue;
+        }
+        // Skip sessions that predate board creation (unless already synced)
+        if (!board.syncedSessions[session.sessionId]) {
+            const updatedAtMs = session.updatedAt ? new Date(session.updatedAt).getTime() : 0;
+            if (updatedAtMs < connectedAtMs) {
+                continue;
+            }
+        }
+        const repo = await getRepoInfo({ cwd: session.cwd });
+        if (!repo) {
+            continue;
+        }
+        // If trackedRepos is empty, track all repos
+        if (board.trackedRepos.length > 0 && !board.trackedRepos.includes(repo.slug)) {
+            continue;
+        }
+        filteredSessions.push({
+            session,
+            repoSlug: repo.slug,
+            repoUrl: repo.url,
+            branch: repo.branch,
+        });
+    }
+    // Sync each session
+    for (const { session, repoSlug, repoUrl, branch } of filteredSessions) {
+        const existingPageId = board.syncedSessions[session.sessionId];
+        if (existingPageId) {
+            // Update existing page
+            await rateLimitedCall(() => {
+                return updateSessionPage({
+                    notion,
+                    pageId: existingPageId,
+                    title: session.title || undefined,
+                    updatedAt: session.updatedAt || undefined,
+                });
+            });
+        }
+        else {
+            // Create new page
+            const title = session.title || `Session ${session.sessionId.slice(0, 8)}`;
+            const branchUrl = `${repoUrl}/tree/${branch}`;
+            const resumeCommand = (() => {
+                if (session.source === 'opencode') {
+                    return `opencode --session ${session.sessionId}`;
+                }
+                return `claude --resume ${session.sessionId}`;
+            })();
+            // Try to get Discord URL if kimaki is available
+            const discordUrl = await getKimakiDiscordUrl(session.sessionId);
+            const pageId = await rateLimitedCall(() => {
+                return createSessionPage({
+                    notion,
+                    databaseId: board.notionDatabaseId,
+                    title,
+                    sessionId: session.sessionId,
+                    status: 'In Progress',
+                    repoSlug,
+                    branchUrl,
+                    resumeCommand,
+                    assigneeId: board.notionUserId,
+                    folder: session.cwd || '',
+                    discordUrl: discordUrl || undefined,
+                    updatedAt: session.updatedAt || undefined,
+                });
+            });
+            board.syncedSessions[session.sessionId] = pageId;
+            console.log(`  + ${title} (${repoSlug})`);
+        }
+    }
+}
+// Try to get Discord URL for a session via kimaki CLI
+async function getKimakiDiscordUrl(sessionId) {
+    return new Promise((resolve) => {
+        execFile('kimaki', ['session', 'discord-url', '--json', sessionId], { timeout: 3000 }, (error, stdout) => {
+            if (error) {
+                resolve(undefined);
+                return;
+            }
+            try {
+                const data = JSON.parse(stdout.trim());
+                resolve(data.url);
+            }
+            catch {
+                resolve(undefined);
+            }
+        });
+    });
+}

package/dist/worker.d.ts

@@ -0,0 +1,6 @@
+import type { Env } from './env.ts';
+declare const _default: {
+    fetch(request: Request, env: Env): Promise<Response>;
+};
+export default _default;
+//# sourceMappingURL=worker.d.ts.map

package/dist/worker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"worker.d.ts","sourceRoot":"","sources":["../src/worker.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,UAAU,CAAA;;mBAiLlB,OAAO,OAAO,GAAG;;AADlC,wBAIC"}