openplexer 0.1.0

package/dist/worker.js

@@ -0,0 +1,151 @@
+// Cloudflare Worker entrypoint for openplexer.
+// Handles Notion OAuth flow: redirects user to Notion, receives callback
+// with auth code, exchanges it for tokens, and stores result in KV for
+// the CLI to poll. Same pattern as kimaki's gateway onboarding.
+import { Spiceflow } from 'spiceflow';
+const REDIRECT_PATH = '/auth/callback';
+const app = new Spiceflow()
+    .state('env', {})
+    .onError(({ error }) => {
+    console.error(error);
+    const message = error instanceof Error ? error.message : String(error);
+    return new Response(message, { status: 500 });
+})
+    .route({
+    method: 'GET',
+    path: '/',
+    handler() {
+        return new Response(null, {
+            status: 302,
+            headers: { Location: 'https://github.com/remorses/kimaki/tree/main/openplexer' },
+        });
+    },
+})
+    .route({
+    method: 'GET',
+    path: '/health',
+    handler() {
+        return { status: 'ok' };
+    },
+})
+    // Step 1: CLI opens browser to this URL. We redirect to Notion OAuth.
+    // The CLI passes a random `state` param to correlate the callback.
+    .route({
+    method: 'GET',
+    path: '/auth/notion',
+    handler({ request, state }) {
+        const url = new URL(request.url);
+        const stateParam = url.searchParams.get('state');
+        if (!stateParam) {
+            return new Response('Missing state parameter', { status: 400 });
+        }
+        const env = state.env;
+        const notionAuthUrl = new URL('https://api.notion.com/v1/oauth/authorize');
+        notionAuthUrl.searchParams.set('client_id', env.NOTION_CLIENT_ID);
+        notionAuthUrl.searchParams.set('response_type', 'code');
+        notionAuthUrl.searchParams.set('owner', 'user');
+        notionAuthUrl.searchParams.set('redirect_uri', new URL(REDIRECT_PATH, url.origin).toString());
+        notionAuthUrl.searchParams.set('state', stateParam);
+        return new Response(null, {
+            status: 302,
+            headers: { Location: notionAuthUrl.toString() },
+        });
+    },
+})
+    // Step 2: Notion redirects here after user authorizes.
+    // We exchange the code for tokens and store in KV.
+    .route({
+    method: 'GET',
+    path: REDIRECT_PATH,
+    async handler({ request, state }) {
+        const url = new URL(request.url);
+        const code = url.searchParams.get('code');
+        const stateParam = url.searchParams.get('state');
+        if (!code || !stateParam) {
+            return new Response('Missing code or state parameter', { status: 400 });
+        }
+        const env = state.env;
+        const redirectUri = new URL(REDIRECT_PATH, url.origin).toString();
+        // Exchange code for tokens
+        const encoded = btoa(`${env.NOTION_CLIENT_ID}:${env.NOTION_CLIENT_SECRET}`);
+        const tokenResponse = await fetch('https://api.notion.com/v1/oauth/token', {
+            method: 'POST',
+            headers: {
+                Accept: 'application/json',
+                'Content-Type': 'application/json',
+                Authorization: `Basic ${encoded}`,
+            },
+            body: JSON.stringify({
+                grant_type: 'authorization_code',
+                code,
+                redirect_uri: redirectUri,
+            }),
+        });
+        if (!tokenResponse.ok) {
+            const errorBody = await tokenResponse.text();
+            console.error('Notion token exchange failed:', errorBody);
+            return new Response(`Notion authorization failed: ${errorBody}`, { status: 500 });
+        }
+        const tokenData = (await tokenResponse.json());
+        // Store tokens in KV with 5 minute TTL
+        const kvPayload = {
+            accessToken: tokenData.access_token,
+            botId: tokenData.bot_id,
+            workspaceId: tokenData.workspace_id,
+            workspaceName: tokenData.workspace_name,
+            notionUserId: tokenData.owner?.user?.id,
+            notionUserName: tokenData.owner?.user?.name,
+        };
+        await env.OPENPLEXER_KV.put(`auth:${stateParam}`, JSON.stringify(kvPayload), {
+            expirationTtl: 300,
+        });
+        // Show success page
+        return new Response(`<!DOCTYPE html>
+<html>
+<head><title>openplexer - Connected</title>
+<style>
+  body { font-family: system-ui, sans-serif; display: flex; justify-content: center;
+         align-items: center; height: 100vh; margin: 0; background: #1a1a2e; color: #eee; }
+  .card { text-align: center; padding: 48px; border-radius: 12px;
+          background: #16213e; max-width: 400px; }
+  h1 { margin: 0 0 16px; font-size: 24px; }
+  p { color: #999; margin: 0; }
+</style>
+</head>
+<body>
+  <div class="card">
+    <h1>Connected to Notion</h1>
+    <p>You can close this tab and return to the CLI.</p>
+  </div>
+</body>
+</html>`, { status: 200, headers: { 'Content-Type': 'text/html' } });
+    },
+})
+    // Step 3: CLI polls this endpoint to get the tokens.
+    .route({
+    method: 'GET',
+    path: '/auth/status',
+    async handler({ request, state }) {
+        const url = new URL(request.url);
+        const stateParam = url.searchParams.get('state');
+        if (!stateParam) {
+            return new Response('Missing state parameter', { status: 400 });
+        }
+        const result = await state.env.OPENPLEXER_KV.get(`auth:${stateParam}`);
+        if (!result) {
+            return new Response(JSON.stringify({ status: 'pending' }), {
+                status: 404,
+                headers: { 'Content-Type': 'application/json' },
+            });
+        }
+        return new Response(result, {
+            status: 200,
+            headers: { 'Content-Type': 'application/json' },
+        });
+    },
+});
+export default {
+    fetch(request, env) {
+        return app.handle(request, { state: { env } });
+    },
+};

package/package.json

@@ -0,0 +1,66 @@
+{
+  "name": "openplexer",
+  "version": "0.1.0",
+  "description": "Track coding sessions in Notion boards. Syncs ACP sessions from OpenCode and Claude Code to collaborative Notion databases.",
+  "type": "module",
+  "main": "./dist/cli.js",
+  "types": "./dist/cli.d.ts",
+  "bin": "dist/cli.js",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "types": "./dist/cli.d.ts",
+      "default": "./dist/cli.js"
+    },
+    "./src": {
+      "types": "./src/cli.ts",
+      "default": "./src/cli.ts"
+    },
+    "./src/*": {
+      "types": "./src/*.ts",
+      "default": "./src/*.ts"
+    }
+  },
+  "files": [
+    "src",
+    "dist",
+    "README.md"
+  ],
+  "dependencies": {
+    "@agentclientprotocol/sdk": "^0.16.1",
+    "@clack/prompts": "^0.10.0",
+    "@notionhq/client": "^5.13.0",
+    "goke": "^6.3.0",
+    "spiceflow": "1.18.0-rsc.11",
+    "errore": "^0.14.1"
+  },
+  "devDependencies": {
+    "@cloudflare/workers-types": "^4.20260130.0",
+    "@types/node": "^22.0.0",
+    "tsx": "^4.21.0",
+    "typescript": "5.8.3",
+    "wrangler": "^4.61.1"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/remorses/kimaki",
+    "directory": "openplexer"
+  },
+  "homepage": "https://openplexer.com",
+  "bugs": "https://github.com/remorses/kimaki/issues",
+  "keywords": [
+    "notion",
+    "coding-sessions",
+    "acp",
+    "opencode",
+    "claude",
+    "session-tracker"
+  ],
+  "scripts": {
+    "build": "rm -rf dist *.tsbuildinfo && tsc && chmod +x dist/cli.js",
+    "dev": "doppler run --mount .dev.vars --mount-format env -- wrangler dev --port 8790",
+    "deployment": "tsc --noEmit && wrangler deploy --env preview",
+    "deployment:production": "tsc --noEmit && wrangler deploy",
+    "secrets:prod": "doppler run -c production --mount .env.prod --mount-format env -- wrangler secret bulk .env.prod"
+  }
+}

package/src/acp-client.ts

@@ -0,0 +1,124 @@
+// 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 { Writable, Readable } from 'node:stream'
+import {
+  ClientSideConnection,
+  ndJsonStream,
+  type Agent,
+  type Client,
+  type SessionInfo,
+} from '@agentclientprotocol/sdk'
+
+function nodeToWebWritable(nodeStream: Writable): WritableStream<Uint8Array> {
+  return new WritableStream<Uint8Array>({
+    write(chunk) {
+      return new Promise<void>((resolve, reject) => {
+        nodeStream.write(Buffer.from(chunk), (err) => {
+          if (err) {
+            reject(err)
+          } else {
+            resolve()
+          }
+        })
+      })
+    },
+  })
+}
+
+function nodeToWebReadable(nodeStream: Readable): ReadableStream<Uint8Array> {
+  return new ReadableStream<Uint8Array>({
+    start(controller) {
+      nodeStream.on('data', (chunk: Buffer) => {
+        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 implements Client {
+  async requestPermission() {
+    return { outcome: { outcome: 'cancelled' as const } }
+  }
+  async sessionUpdate() {}
+  async readTextFile() {
+    return { content: '' }
+  }
+  async writeTextFile() {
+    return {}
+  }
+}
+
+export type AcpConnection = {
+  connection: ClientSideConnection
+  client: 'opencode' | 'claude'
+  kill: () => void
+}
+
+export async function connectAcp({
+  client,
+}: {
+  client: 'opencode' | 'claude'
+}): Promise<AcpConnection> {
+  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: Agent) => {
+    return new MinimalClient()
+  }, stream)
+
+  await connection.initialize({
+    protocolVersion: 1,
+    clientCapabilities: {},
+  })
+
+  return {
+    connection,
+    client,
+    kill: () => {
+      child.kill()
+    },
+  }
+}
+
+export async function listAllSessions({
+  connection,
+}: {
+  connection: ClientSideConnection
+}): 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
+}