openplexer 0.1.0 → 0.2.0

package/src/acp-client.ts

@@ -1,7 +1,16 @@
-// Spawn an ACP agent (opencode or claude) as a child process and connect
-// as a client via stdio. Uses @agentclientprotocol/sdk for the protocol.
+// Connect to coding agents and list their sessions.
+//
+// opencode: spawns `opencode serve` and uses the HTTP API's
+//   /experimental/session endpoint which returns sessions across ALL
+//   projects (Session.listGlobal). The ACP protocol's listSessions
+//   calls Session.list which is scoped to a single project — that's
+//   why we bypass ACP for opencode.
+//
+// claude / codex: uses ACP over stdio (unchanged).
 
-import { spawn } from 'node:child_process'
+import { spawn, type ChildProcess } from 'node:child_process'
+import { createRequire } from 'node:module'
+import path from 'node:path'
 import { Writable, Readable } from 'node:stream'
 import {
   ClientSideConnection,
@@ -10,6 +19,102 @@ import {
   type Client,
   type SessionInfo,
 } from '@agentclientprotocol/sdk'
+import { createOpencodeClient } from '@opencode-ai/sdk/v2'
+import type { AcpClient } from './config.ts'
+
+// ---------------------------------------------------------------------------
+// Shared types
+// ---------------------------------------------------------------------------
+
+export type AgentConnection = {
+  client: AcpClient
+  listSessions: () => Promise<SessionInfo[]>
+  kill: () => void
+}
+
+// Keep the old type as an alias for backwards compat in sync.ts
+export type AcpConnection = AgentConnection
+
+// ---------------------------------------------------------------------------
+// opencode — HTTP server with /experimental/session (global, all projects)
+// ---------------------------------------------------------------------------
+
+async function connectOpencode(): Promise<AgentConnection> {
+  const PORT = 18_923
+  const baseUrl = `http://127.0.0.1:${PORT}`
+
+  // Spawn `opencode serve` on a known port. cwd doesn't matter since
+  // we use the global endpoint.
+  const child = spawn('opencode', ['serve', '--port', String(PORT)], {
+    stdio: ['pipe', 'pipe', 'pipe'],
+    cwd: '/',
+  })
+
+  const sdk = createOpencodeClient({ baseUrl })
+
+  // Wait for the server to be ready (poll until it responds)
+  const deadline = Date.now() + 15_000
+  while (Date.now() < deadline) {
+    try {
+      const res = await fetch(`${baseUrl}/session?limit=1`)
+      if (res.ok) break
+    } catch {
+      // server not ready yet
+    }
+    await new Promise((r) => setTimeout(r, 200))
+  }
+
+  // Verify it's actually up
+  const check = await fetch(`${baseUrl}/session?limit=1`).catch(() => null)
+  if (!check?.ok) {
+    child.kill()
+    throw new Error('opencode serve failed to start')
+  }
+
+  return {
+    client: 'opencode',
+    listSessions: async () => {
+      const sessions: SessionInfo[] = []
+      let cursor: number | undefined
+
+      // Paginate through /experimental/session which uses Session.listGlobal()
+      // (returns sessions across ALL projects, not scoped to one)
+      while (true) {
+        const result = await sdk.experimental.session.list({
+          roots: true,
+          ...(cursor !== undefined && { cursor }),
+        })
+
+        if (result.error || !result.data) {
+          throw new Error(`opencode API error: ${result.error}`)
+        }
+
+        for (const s of result.data) {
+          sessions.push({
+            sessionId: s.id,
+            cwd: s.directory,
+            title: s.title,
+            updatedAt: new Date(s.time.updated).toISOString(),
+          })
+        }
+
+        // Pagination cursor is in the x-next-cursor response header
+        const nextCursor = result.response.headers.get('x-next-cursor')
+        if (!nextCursor) break
+        cursor = Number(nextCursor)
+      }
+
+      return sessions
+    },
+    kill: () => {
+      child.kill()
+    },
+  }
+}
+
+// ---------------------------------------------------------------------------
+// claude / codex — ACP over stdio
+// ---------------------------------------------------------------------------
 
 function nodeToWebWritable(nodeStream: Writable): WritableStream<Uint8Array> {
   return new WritableStream<Uint8Array>({
@@ -43,9 +148,6 @@ function nodeToWebReadable(nodeStream: Readable): ReadableStream<Uint8Array> {
   })
 }
 
-// Minimal Client implementation — we only need session listing,
-// not file ops or permissions. requestPermission and sessionUpdate
-// are required by the Client interface.
 class MinimalClient implements Client {
   async requestPermission() {
     return { outcome: { outcome: 'cancelled' as const } }
@@ -59,22 +161,28 @@ class MinimalClient implements Client {
   }
 }
 
-export type AcpConnection = {
-  connection: ClientSideConnection
-  client: 'opencode' | 'claude'
-  kill: () => void
+function resolveAcpBinary(client: 'claude' | 'codex'): { cmd: string; args: string[] } {
+  const require = createRequire(import.meta.url)
+  const packageName = client === 'claude'
+    ? '@zed-industries/claude-agent-acp'
+    : '@zed-industries/codex-acp'
+  const binName = client === 'claude' ? 'claude-agent-acp' : 'codex-acp'
+
+  const pkgJsonPath = require.resolve(`${packageName}/package.json`)
+  const pkgDir = path.dirname(pkgJsonPath)
+  const pkg = require(pkgJsonPath) as { bin: string | Record<string, string> }
+  const binRelative = typeof pkg.bin === 'string' ? pkg.bin : pkg.bin[binName]
+  const binPath = path.resolve(pkgDir, binRelative)
+
+  return { cmd: process.execPath, args: [binPath] }
 }
 
-export async function connectAcp({
-  client,
-}: {
-  client: 'opencode' | 'claude'
-}): Promise<AcpConnection> {
-  const cmd = client === 'opencode' ? 'opencode' : 'claude'
-  const args = ['acp']
+async function connectAcpAgent(client: 'claude' | 'codex'): Promise<AgentConnection> {
+  const { cmd, args } = resolveAcpBinary(client)
 
   const child = spawn(cmd, args, {
     stdio: ['pipe', 'pipe', 'inherit'],
+    cwd: '/',
   })
 
   const stream = ndJsonStream(
@@ -92,33 +200,48 @@ export async function connectAcp({
   })
 
   return {
-    connection,
     client,
+    listSessions: async () => {
+      const sessions: SessionInfo[] = []
+      let cursor: string | undefined
+
+      while (true) {
+        const response = await connection.listSessions({
+          ...(cursor ? { cursor } : {}),
+        })
+        sessions.push(...response.sessions)
+        if (!response.nextCursor) break
+        cursor = response.nextCursor
+      }
+
+      return sessions
+    },
     kill: () => {
       child.kill()
     },
   }
 }
 
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+
+export async function connectAgent({ client }: { client: AcpClient }): Promise<AgentConnection> {
+  if (client === 'opencode') {
+    return connectOpencode()
+  }
+  return connectAcpAgent(client)
+}
+
+// Legacy exports for backwards compat
+export async function connectAcp({ client }: { client: AcpClient }): Promise<AgentConnection> {
+  return connectAgent({ client })
+}
+
 export async function listAllSessions({
   connection,
 }: {
-  connection: ClientSideConnection
+  connection: AgentConnection
 }): Promise<SessionInfo[]> {
-  const sessions: SessionInfo[] = []
-  let cursor: string | undefined
-
-  // 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
+  return connection.listSessions()
 }

package/src/cli.ts

@@ -21,9 +21,9 @@ 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 { connectAgent, type AgentConnection } from './acp-client.ts'
 import { getRepoInfo } from './git.ts'
-import { createNotionClient, createBoardDatabase, getRootPages } from './notion.ts'
+import { createNotionClient, createBoardDatabase, createExamplePage, getRootPages } from './notion.ts'
 import { evictExistingInstance, getLockPort, startLockServer } from './lock.ts'
 import { startSyncLoop } from './sync.ts'
 import {
@@ -149,6 +149,7 @@ async function connectFlow(): Promise<void> {
       options: [
         { value: 'opencode' as const, label: 'OpenCode' },
         { value: 'claude' as const, label: 'Claude Code' },
+        { value: 'codex' as const, label: 'Codex' },
       ],
       required: true,
     })
@@ -169,8 +170,8 @@ async function connectFlow(): Promise<void> {
 
   for (const client of config.clients) {
     try {
-      const acp = await connectAcp({ client })
-      const sessions = await listAllSessions({ connection: acp.connection })
+      const acp = await connectAgent({ client })
+      const sessions = await acp.listSessions()
 
       // Extract unique repos from session cwds
       const cwds = [...new Set(sessions.map((sess) => sess.cwd).filter(Boolean))] as string[]
@@ -240,6 +241,7 @@ async function connectFlow(): Promise<void> {
     workspaceName: string
     notionUserId?: string
     notionUserName?: string
+    duplicatedTemplateId?: string | null
   }
   let authResult: AuthResult | undefined
   const maxAttempts = 150 // 5 minutes at 2s intervals
@@ -305,12 +307,15 @@ async function connectFlow(): Promise<void> {
     return pageChoice
   })()
 
-  // Step 6: Create database
+  // Step 6: Create database and seed with an example page
   s.start('Creating board database...')
   const { databaseId } = await createBoardDatabase({ notion, pageId })
+  await createExamplePage({ notion, databaseId })
   s.stop('Board database created')
 
-  log.success('Open the database in Notion and click "+ Add a view" → Board, grouped by Status.')
+  // Show link to the Notion page so user can open it directly
+  const notionPageUrl = `https://notion.so/${pageId.replace(/-/g, '')}`
+  log.success(`Board created: ${notionPageUrl}`)
 
   // Step 7: Save to config
   const board: OpenplexerBoard = {
@@ -347,15 +352,10 @@ async function connectFlow(): Promise<void> {
     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! Starting sync, keep this process running.')
 
-  outro('Board connected! Sync daemon started in background.')
+  // Transition directly into the sync daemon instead of spawning a child
+  await startDaemon(config)
 }
 
 // --- Daemon ---
@@ -367,10 +367,10 @@ async function startDaemon(config: OpenplexerConfig): Promise<void> {
 
   console.log(`openplexer daemon started (PID ${process.pid}, port ${port})`)
 
-  const connections: AcpConnection[] = []
+  const connections: AgentConnection[] = []
   for (const client of config.clients) {
     try {
-      const acp = await connectAcp({ client })
+      const acp = await connectAgent({ client })
       connections.push(acp)
       console.log(`Connected to ${client} via ACP`)
     } catch {

package/src/config.ts

@@ -30,7 +30,7 @@ export type OpenplexerBoard = {
   connectedAt: string
 }
 
-export type AcpClient = 'opencode' | 'claude'
+export type AcpClient = 'opencode' | 'claude' | 'codex'
 
 export type OpenplexerConfig = {
   /** ACP clients to connect to (user may use both opencode and claude) */

package/src/notion.ts

@@ -7,8 +7,6 @@ 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 = {
@@ -26,10 +24,10 @@ export type RootPage = {
   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.
+// Get root-level pages (parent.type === 'workspace') using notion.search.
+// Only pages are returned (not databases). With OAuth integrations,
+// only pages the user explicitly shared during consent are searchable,
+// so users must share root-level pages for them to appear here.
 export async function getRootPages({ notion }: { notion: Client }): Promise<RootPage[]> {
   const pages: RootPage[] = []
   let startCursor: string | undefined
@@ -46,6 +44,10 @@ export async function getRootPages({ notion }: { notion: Client }): Promise<Root
       if (!('parent' in result) || !('properties' in result)) {
         continue
       }
+      // Only show root pages (direct children of workspace), skip databases
+      if (result.object !== 'page' || result.parent.type !== 'workspace') {
+        continue
+      }
 
       const titleProp = Object.values(result.properties).find((p) => p.type === 'title')
       const title = (() => {
@@ -86,6 +88,7 @@ export async function createBoardDatabase({
 }): Promise<CreateDatabaseResult> {
   const database = await notion.databases.create({
     parent: { type: 'page_id', page_id: pageId },
+    is_inline: true,
     title: [{ text: { content: 'openplexer - Coding Sessions' } }],
     initial_data_source: {
       properties: {
@@ -108,22 +111,172 @@ export async function createBoardDatabase({
   })
 
   // Database is created with a default Table view. Create a Board view
-  // grouped by Status so sessions show as a kanban board.
+  // grouped by Status so sessions show as a kanban board, then delete the
+  // default Table view so Board becomes the default.
   const dataSourceId = 'data_sources' in database
     ? database.data_sources?.[0]?.id
     : undefined
   if (dataSourceId) {
+    // Retrieve the data source to get the Status property ID for group_by
+    const dataSource = await notion.dataSources.retrieve({ data_source_id: dataSourceId })
+    const statusPropertyId = 'properties' in dataSource
+      ? Object.entries(dataSource.properties as Record<string, { id: string; type: string }>)
+          .find(([name]) => name === 'Status')?.[1]?.id
+      : undefined
+
+    // List existing views (should contain the auto-created Table view)
+    const existingViews = await notion.views.list({ database_id: database.id })
+    const tableViewIds = existingViews.results.map((v) => v.id)
+
+    // Create the Board view, grouped by Status
     await notion.views.create({
       database_id: database.id,
       data_source_id: dataSourceId,
       name: 'Board',
       type: 'board',
+      ...(statusPropertyId && {
+        configuration: {
+          type: 'board' as const,
+          group_by: {
+            type: 'select' as const,
+            property_id: statusPropertyId,
+            sort: { type: 'manual' as const },
+            hide_empty_groups: false,
+          },
+        },
+      }),
     })
+
+    // Delete the default Table view(s) so Board is the only (and default) view
+    for (const viewId of tableViewIds) {
+      await notion.views.delete({ view_id: viewId }).catch(() => {
+        // Ignore errors — can't delete the last view, but we just created Board
+      })
+    }
   }
 
   return { databaseId: database.id }
 }
 
+// Create an example page in the database explaining how sessions appear.
+export async function createExamplePage({
+  notion,
+  databaseId,
+}: {
+  notion: Client
+  databaseId: string
+}): Promise<string> {
+  const page = await notion.pages.create({
+    parent: { database_id: databaseId },
+    properties: {
+      Name: { title: [{ text: { content: 'Sessions will appear here automatically' } }] },
+      Status: { select: { name: 'In Progress' } },
+      'Session ID': { rich_text: [{ text: { content: 'example' } }] },
+      Repo: { select: { name: 'owner/repo' } },
+      Resume: { rich_text: [{ text: { content: 'opencode --session <id>' } }] },
+      Folder: { rich_text: [{ text: { content: '/path/to/project' } }] },
+    } as Parameters<Client['pages']['create']>[0]['properties'],
+    children: [
+      {
+        type: 'paragraph',
+        paragraph: {
+          rich_text: [
+            {
+              type: 'text',
+              text: { content: 'Each card on this board represents a coding session from OpenCode, Claude Code, or Codex. openplexer syncs them automatically every few seconds.' },
+            },
+          ],
+        },
+      },
+      { type: 'divider', divider: {} },
+      {
+        type: 'heading_3',
+        heading_3: {
+          rich_text: [{ type: 'text', text: { content: 'What each field means' } }],
+        },
+      },
+      {
+        type: 'bulleted_list_item',
+        bulleted_list_item: {
+          rich_text: [
+            { type: 'text', text: { content: 'Status' }, annotations: { bold: true } },
+            { type: 'text', text: { content: ' — In Progress while the session is active, Done when finished. You can set Needs Attention or Ignored manually.' } },
+          ],
+        },
+      },
+      {
+        type: 'bulleted_list_item',
+        bulleted_list_item: {
+          rich_text: [
+            { type: 'text', text: { content: 'Repo' }, annotations: { bold: true } },
+            { type: 'text', text: { content: ' — The GitHub repository the session is working in (owner/repo).' } },
+          ],
+        },
+      },
+      {
+        type: 'bulleted_list_item',
+        bulleted_list_item: {
+          rich_text: [
+            { type: 'text', text: { content: 'Branch' }, annotations: { bold: true } },
+            { type: 'text', text: { content: ' — Link to the git branch on GitHub.' } },
+          ],
+        },
+      },
+      {
+        type: 'bulleted_list_item',
+        bulleted_list_item: {
+          rich_text: [
+            { type: 'text', text: { content: 'Resume' }, annotations: { bold: true } },
+            { type: 'text', text: { content: ' — Command to resume the session in your terminal.' } },
+          ],
+        },
+      },
+      {
+        type: 'bulleted_list_item',
+        bulleted_list_item: {
+          rich_text: [
+            { type: 'text', text: { content: 'Share URL' }, annotations: { bold: true } },
+            { type: 'text', text: { content: ' — Public share link for the session (if available).' } },
+          ],
+        },
+      },
+      {
+        type: 'bulleted_list_item',
+        bulleted_list_item: {
+          rich_text: [
+            { type: 'text', text: { content: 'Discord' }, annotations: { bold: true } },
+            { type: 'text', text: { content: ' — Link to the Discord thread (if using kimaki).' } },
+          ],
+        },
+      },
+      {
+        type: 'bulleted_list_item',
+        bulleted_list_item: {
+          rich_text: [
+            { type: 'text', text: { content: 'Assignee' }, annotations: { bold: true } },
+            { type: 'text', text: { content: ' — The Notion user who authorized the integration.' } },
+          ],
+        },
+      },
+      { type: 'divider', divider: {} },
+      {
+        type: 'paragraph',
+        paragraph: {
+          rich_text: [
+            {
+              type: 'text',
+              text: { content: 'You can archive this card once real sessions start appearing.' },
+              annotations: { italic: true, color: 'gray' },
+            },
+          ],
+        },
+      },
+    ] as Parameters<Client['blocks']['children']['append']>[0]['children'],
+  })
+
+  return page.id
+}
+
 export async function createSessionPage({
   notion,
   databaseId,