openplexer 0.1.0

package/src/notion.ts

@@ -0,0 +1,233 @@
+// 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' as const },
+  { name: 'In Progress', color: 'blue' as const },
+  { name: 'Done', color: 'green' as const },
+  { name: 'Needs Attention', color: 'red' as const },
+  { name: 'Ignored', color: 'gray' as const },
+]
+
+export type CreateDatabaseResult = {
+  databaseId: string
+}
+
+export function createNotionClient({ token }: { token: string }): Client {
+  return new Client({ auth: token })
+}
+
+export type RootPage = {
+  id: string
+  title: string
+  url: string
+  icon: string
+}
+
+// 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 }: { notion: Client }): Promise<RootPage[]> {
+  const pages: RootPage[] = []
+  let startCursor: string | undefined
+
+  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: { plain_text: string }) => 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,
+}: {
+  notion: Client
+  pageId: string
+}): Promise<CreateDatabaseResult> {
+  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,
+}: {
+  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> {
+  const properties: Record<string, unknown> = {
+    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 as Parameters<Client['pages']['create']>[0]['properties'],
+  })
+
+  return page.id
+}
+
+export async function updateSessionPage({
+  notion,
+  pageId,
+  title,
+  updatedAt,
+}: {
+  notion: Client
+  pageId: string
+  title?: string
+  updatedAt?: string
+}): Promise<void> {
+  const properties: Record<string, unknown> = {}
+
+  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 as Parameters<Client['pages']['update']>[0]['properties'],
+  })
+}
+
+// Rate-limited queue for Notion API calls (max 3/sec)
+const RATE_LIMIT_MS = 350
+let lastCallTime = 0
+
+export async function rateLimitedCall<T>(fn: () => Promise<T>): Promise<T> {
+  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/src/startup-service.ts

@@ -0,0 +1,175 @@
+// 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: string): Promise<{ stdout: string; stderr: string }> {
+  return new Promise((resolve, reject) => {
+    _exec(command, { timeout: 5000 }, (error, stdout, stderr) => {
+      if (error) {
+        reject(error)
+        return
+      }
+      resolve({ stdout, stderr })
+    })
+  })
+}
+
+function getServiceFilePath(): string {
+  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: string): string {
+  return value.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;')
+}
+
+function shellEscape(value: string): string {
+  if (/^[a-zA-Z0-9._/=-]+$/.test(value)) {
+    return value
+  }
+  return `"${value.replace(/"/g, '\\"')}"`
+}
+
+function buildMacOSPlist({ command, args }: { command: string; args: string[] }): string {
+  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 }: { command: string; args: string[] }): string {
+  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 type StartupServiceOptions = {
+  command: string
+  args: string[]
+}
+
+export async function enableStartupService({ command, args }: StartupServiceOptions): Promise<void> {
+  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<void>((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(): Promise<void> {
+  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(): Promise<boolean> {
+  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(): string {
+  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/src/sync.ts

@@ -0,0 +1,193 @@
+// 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 type { SessionInfo } from '@agentclientprotocol/sdk'
+import type { OpenplexerBoard, OpenplexerConfig, AcpClient } from './config.ts'
+import { writeConfig } from './config.ts'
+import { listAllSessions, type AcpConnection } from './acp-client.ts'
+import { getRepoInfo } from './git.ts'
+import {
+  createNotionClient,
+  createSessionPage,
+  updateSessionPage,
+  rateLimitedCall,
+} from './notion.ts'
+import { execFile } from 'node:child_process'
+
+const SYNC_INTERVAL_MS = 5000
+
+type TaggedSession = SessionInfo & { source: AcpClient }
+
+export async function startSyncLoop({
+  config,
+  acpConnections,
+}: {
+  config: OpenplexerConfig
+  acpConnections: AcpConnection[]
+}): Promise<void> {
+  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,
+}: {
+  config: OpenplexerConfig
+  acpConnections: AcpConnection[]
+}): Promise<void> {
+  // Collect sessions from all ACP connections, tagged with their source
+  const sessions: TaggedSession[] = []
+  const seenIds = new Set<string>()
+
+  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,
+}: {
+  board: OpenplexerBoard
+  sessions: TaggedSession[]
+}): Promise<void> {
+  const notion = createNotionClient({ token: board.notionToken })
+
+  // Filter sessions to tracked repos
+  const filteredSessions: Array<{
+    session: TaggedSession
+    repoSlug: string
+    repoUrl: string
+    branch: string
+  }> = []
+
+  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: string): Promise<string | undefined> {
+  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()) as { url?: string }
+          resolve(data.url)
+        } catch {
+          resolve(undefined)
+        }
+      },
+    )
+  })
+}