openplexer 0.1.0

package/src/cli.ts

@@ -0,0 +1,387 @@
+#!/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, type OpenplexerConfig, type OpenplexerBoard, type AcpClient } from './config.ts'
+import { connectAcp, listAllSessions, type AcpConnection } from './acp-client.ts'
+import { getRepoInfo } from './git.ts'
+import { createNotionClient, createBoardDatabase, getRootPages } from './notion.ts'
+import { evictExistingInstance, getLockPort, startLockServer } from './lock.ts'
+import { startSyncLoop } from './sync.ts'
+import {
+  enableStartupService,
+  disableStartupService,
+  isStartupServiceEnabled,
+  getServiceLocationDescription,
+} from './startup-service.ts'
+
+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(() => ({}))) as { pid?: number }
+  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(): Promise<void> {
+  intro('openplexer — connect a Notion board')
+
+  const config = readConfig() || ({ clients: [], boards: [] } as OpenplexerConfig)
+
+  // 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' as const, label: 'OpenCode' },
+        { value: 'claude' as const, 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: string[] = []
+  const connectedClients: AcpClient[] = []
+
+  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))] as string[]
+      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: string[] = []
+  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...')
+
+  // Poll for token
+  type AuthResult = {
+    accessToken: string
+    botId: string
+    workspaceId: string
+    workspaceName: string
+    notionUserId?: string
+    notionUserName?: string
+  }
+  let authResult: AuthResult | undefined
+  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()) as AuthResult
+      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: string = 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: OpenplexerBoard = {
+    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: OpenplexerConfig): Promise<void> {
+  const port = getLockPort()
+  await evictExistingInstance({ port })
+  startLockServer({ port })
+
+  console.log(`openplexer daemon started (PID ${process.pid}, port ${port})`)
+
+  const connections: AcpConnection[] = []
+  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/src/config.ts

@@ -0,0 +1,63 @@
+// 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'
+
+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[]
+}
+
+const CONFIG_DIR = path.join(os.homedir(), '.openplexer')
+const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json')
+
+export function getConfigDir(): string {
+  return CONFIG_DIR
+}
+
+export function readConfig(): OpenplexerConfig | undefined {
+  try {
+    const raw = fs.readFileSync(CONFIG_FILE, 'utf-8')
+    return JSON.parse(raw) as OpenplexerConfig
+  } catch {
+    return undefined
+  }
+}
+
+export function writeConfig(config: OpenplexerConfig): void {
+  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/src/env.ts

@@ -0,0 +1,9 @@
+// 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 type Env = {
+  OPENPLEXER_KV: KVNamespace
+  NOTION_CLIENT_ID: string
+  NOTION_CLIENT_SECRET: string
+}

package/src/git.ts

@@ -0,0 +1,84 @@
+// Extract git repo info from session cwd paths.
+// Parses the remote origin URL to get owner/repo.
+
+import { execFile } from 'node:child_process'
+
+export type RepoInfo = {
+  owner: string
+  repo: string
+  /** e.g. "owner/repo" */
+  slug: string
+  /** Full GitHub URL */
+  url: string
+  /** Current branch name */
+  branch: string
+}
+
+export async function getRepoInfo({ cwd }: { cwd: string }): Promise<RepoInfo | undefined> {
+  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: string): { owner: string; repo: string; slug: string; url: string } | undefined {
+  // 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: string, args: string[]): Promise<string> {
+  return new Promise((resolve, reject) => {
+    execFile(cmd, args, { timeout: 5000 }, (error, stdout) => {
+      if (error) {
+        reject(error)
+        return
+      }
+      resolve(stdout)
+    })
+  })
+}

package/src/lock.ts

@@ -0,0 +1,65 @@
+// 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(): number {
+  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 }: { port: number }): Promise<void> {
+  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(() => ({}))) as { pid?: number }
+  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 }: { port: number }): http.Server {
+  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
+}