pragma-so 0.1.0

package/index.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+
+import "./cli";

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "pragma-so",
+  "version": "0.1.0",
+  "description": "Very minimal pragma CLI",
+  "main": "dist/cli/index.js",
+  "bin": {
+    "pragma": "dist/cli/index.js"
+  },
+  "scripts": {
+    "build": "tsc && npm run ui:build",
+    "start": "node dist/cli/index.js",
+    "ui:dev": "vite --config ui/vite.config.mjs ui",
+    "ui:build": "vite build --config ui/vite.config.mjs ui",
+    "ui:preview": "vite preview --config ui/vite.config.mjs ui"
+  },
+  "keywords": [
+    "cli",
+    "commander",
+    "typescript"
+  ],
+  "author": "",
+  "license": "ISC",
+  "type": "commonjs",
+  "dependencies": {
+    "@electric-sql/pglite": "^0.3.16",
+    "@emoji-mart/data": "^1.2.1",
+    "@emoji-mart/react": "^1.1.1",
+    "@hono/node-server": "^1.19.11",
+    "@hono/zod-validator": "^0.7.6",
+    "@types/mime-types": "^3.0.1",
+    "commander": "^14.0.3",
+    "date-fns": "^4.1.0",
+    "eventsource-parser": "^3.0.6",
+    "execa": "^5.1.1",
+    "framer-motion": "^12.38.0",
+    "hono": "^4.12.7",
+    "lucide-react": "^0.577.0",
+    "mime-types": "^3.0.2",
+    "open": "^8.4.2",
+    "papaparse": "^5.5.3",
+    "react": "^18.3.1",
+    "react-dom": "^18.3.1",
+    "react-markdown": "^10.1.0",
+    "remark-gfm": "^4.0.1",
+    "zod": "^4.3.6"
+  },
+  "devDependencies": {
+    "@types/node": "^25.4.0",
+    "@vitejs/plugin-react": "^4.3.1",
+    "typescript": "^5.9.3",
+    "vite": "^5.4.11"
+  }
+}

package/server/connectorBinaries.ts

@@ -0,0 +1,103 @@
+import { join } from "node:path";
+import { access, mkdir, chmod, readdir, rename, unlink } from "node:fs/promises";
+import { createWriteStream } from "node:fs";
+import { pipeline } from "node:stream/promises";
+import { execSync } from "node:child_process";
+import { getWorkspacePaths } from "./db";
+
+export async function ensureConnectorBinary(
+  binaryName: string,
+  downloadUrl: string,
+  workspaceName: string,
+): Promise<string> {
+  const binDir = getWorkspacePaths(workspaceName).binDir;
+  const binPath = join(binDir, binaryName);
+
+  try {
+    await access(binPath);
+    return binPath;
+  } catch {
+    // need to download
+  }
+
+  await mkdir(binDir, { recursive: true });
+
+  if (downloadUrl.startsWith("npm:")) {
+    const pkg = downloadUrl.slice(4);
+    const modulesDir = join(binDir, "node_modules");
+    execSync(`npm install --prefix "${binDir}" ${pkg}`, { stdio: "pipe" });
+    // Try to find the binary in the installed package
+    const pkgBinDir = join(modulesDir, ".bin");
+    const pkgBinPath = join(pkgBinDir, binaryName);
+    try {
+      await access(pkgBinPath);
+      // Symlink or copy to binDir
+      const { symlinkSync } = await import("node:fs");
+      try {
+        symlinkSync(pkgBinPath, binPath);
+      } catch {
+        // Already exists or can't symlink — that's fine
+      }
+    } catch {
+      // Binary might be directly in modulesDir — best effort
+    }
+    return binPath;
+  }
+
+  // Download .tar.gz, extract the binary
+  const response = await fetch(downloadUrl);
+  if (!response.ok) {
+    throw new Error(`Download failed: ${response.status} ${response.statusText}`);
+  }
+
+  const tmpFile = join(binDir, `_download_${binaryName}.tar.gz`);
+  const tmpExtractDir = join(binDir, `_extract_${binaryName}`);
+
+  try {
+    // Write response to temp file
+    const body = response.body;
+    if (!body) {
+      throw new Error("Empty response body");
+    }
+    const fileStream = createWriteStream(tmpFile);
+    await pipeline(body, fileStream);
+
+    // Extract tar.gz
+    await mkdir(tmpExtractDir, { recursive: true });
+    execSync(`tar xzf "${tmpFile}" -C "${tmpExtractDir}"`, { stdio: "pipe" });
+
+    // Find the binary in extracted files (search recursively)
+    const found = await findBinaryInDir(tmpExtractDir, binaryName);
+    if (found) {
+      await rename(found, binPath);
+      await chmod(binPath, 0o755);
+    } else {
+      throw new Error(`Binary '${binaryName}' not found in downloaded archive`);
+    }
+  } finally {
+    // Cleanup temp files
+    try { await unlink(tmpFile); } catch { /* ignore */ }
+    try { execSync(`rm -rf "${tmpExtractDir}"`, { stdio: "pipe" }); } catch { /* ignore */ }
+  }
+
+  return binPath;
+}
+
+async function findBinaryInDir(dir: string, name: string): Promise<string | null> {
+  const entries = await readdir(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const full = join(dir, entry.name);
+    if (entry.isFile() && entry.name === name) {
+      return full;
+    }
+    if (entry.isDirectory()) {
+      const found = await findBinaryInDir(full, name);
+      if (found) return found;
+    }
+  }
+  return null;
+}
+
+export function getConnectorBinDir(workspaceName: string): string {
+  return getWorkspacePaths(workspaceName).binDir;
+}

package/server/connectorRegistry.ts

@@ -0,0 +1,158 @@
+export interface ConnectorDef {
+  name: string;
+  displayName: string;
+  description: string;
+  content: string;
+  provider: string;
+  binaryName: string;
+  envVar: string;
+  authType: "oauth2";
+  oauthAuthUrl: string;
+  oauthTokenUrl: string;
+  scopes: string;
+  proxyProvider?: string;
+  getBinaryUrl(platform: string, arch: string): string;
+}
+
+export const OAUTH_PROXY_URL = process.env.PRAGMA_OAUTH_PROXY_URL || 'https://pragma-production-f107.up.railway.app';
+
+export const CONNECTOR_REGISTRY: ConnectorDef[] = [
+  {
+    name: "google-workspace",
+    displayName: "Google Workspace",
+    description: "Google Calendar, Gmail, Drive, Sheets, Docs via gws CLI",
+    content: `# Google Workspace
+
+You have access to Google Workspace services via the \`gws\` CLI.
+Authentication is pre-configured — just run commands directly.
+
+## Calendar
+\`\`\`
+gws calendar events list --calendar-id primary --max-results 10
+gws calendar events insert --calendar-id primary --summary "Meeting" --start-date-time "2024-03-20T10:00:00Z" --end-date-time "2024-03-20T11:00:00Z"
+\`\`\`
+
+## Gmail
+\`\`\`
+gws gmail messages list --user-id me --max-results 10 --query "is:unread"
+gws gmail messages get --user-id me --id <messageId>
+gws gmail messages send --user-id me --to "user@example.com" --subject "Subject" --body "Body"
+\`\`\`
+
+## Drive
+\`\`\`
+gws drive files list --page-size 10
+gws drive files get --file-id <fileId>
+\`\`\`
+
+## Sheets
+\`\`\`
+gws sheets spreadsheets-values get --spreadsheet-id <id> --range "Sheet1!A1:D10"
+\`\`\`
+
+Run \`gws <service> --help\` to discover all available commands.
+`,
+    provider: "google",
+    binaryName: "gws",
+    envVar: "GOOGLE_WORKSPACE_CLI_TOKEN",
+    authType: "oauth2",
+    oauthAuthUrl: "https://accounts.google.com/o/oauth2/v2/auth",
+    oauthTokenUrl: "https://oauth2.googleapis.com/token",
+    scopes:
+      "https://www.googleapis.com/auth/calendar https://www.googleapis.com/auth/gmail.modify https://www.googleapis.com/auth/drive https://www.googleapis.com/auth/spreadsheets",
+    proxyProvider: "google",
+    getBinaryUrl: (platform: string, arch: string) => {
+      const targets: Record<string, string> = {
+        "darwin-arm64": "aarch64-apple-darwin",
+        "darwin-x64": "x86_64-apple-darwin",
+        "linux-arm64": "aarch64-unknown-linux-gnu",
+        "linux-x64": "x86_64-unknown-linux-gnu",
+      };
+      const target =
+        targets[`${platform}-${arch}`] ?? "x86_64-unknown-linux-gnu";
+      return `https://github.com/googleworkspace/cli/releases/download/v0.17.0/gws-${target}.tar.gz`;
+    },
+  },
+  {
+    name: "slack",
+    displayName: "Slack",
+    description: "Send messages, read channels, manage Slack workspace",
+    content: `# Slack
+
+You have access to Slack via the \`agent-slack\` CLI.
+Authentication is pre-configured.
+
+## Send a message
+\`\`\`
+agent-slack send --channel "#general" --text "Hello from Pragma"
+\`\`\`
+
+## Read messages
+\`\`\`
+agent-slack read --channel "#general" --limit 20
+\`\`\`
+
+## List channels
+\`\`\`
+agent-slack channels
+\`\`\`
+
+Run \`agent-slack --help\` to see all commands.
+`,
+    provider: "slack",
+    binaryName: "agent-slack",
+    envVar: "SLACK_TOKEN",
+    authType: "oauth2",
+    oauthAuthUrl: "https://slack.com/oauth/v2/authorize",
+    oauthTokenUrl: "https://slack.com/api/oauth.v2.access",
+    scopes: "chat:write channels:read channels:history groups:read im:read",
+    proxyProvider: "slack",
+    getBinaryUrl: () => "npm:agent-slack",
+  },
+  {
+    name: "notion",
+    displayName: "Notion",
+    description: "Search, read, and create Notion pages and databases",
+    content: `# Notion
+
+You have access to Notion via the \`notion\` CLI.
+Authentication is pre-configured.
+
+## Search
+\`\`\`
+notion search --query "project plan"
+\`\`\`
+
+## Pages
+\`\`\`
+notion page get <page-id>
+notion page create --parent <parent-id> --title "New Page" --content "Page content"
+\`\`\`
+
+## Databases
+\`\`\`
+notion db list
+notion db query <database-id> --filter '{"property":"Status","select":{"equals":"In Progress"}}'
+\`\`\`
+
+Run \`notion --help\` to see all commands.
+`,
+    provider: "notion",
+    binaryName: "notion",
+    envVar: "NOTION_TOKEN",
+    authType: "oauth2",
+    oauthAuthUrl: "https://api.notion.com/v1/oauth/authorize",
+    oauthTokenUrl: "https://api.notion.com/v1/oauth/token",
+    scopes: "",
+    getBinaryUrl: (platform: string, arch: string) => {
+      const targets: Record<string, string> = {
+        "darwin-arm64": "darwin_arm64",
+        "darwin-x64": "darwin_amd64",
+        "linux-arm64": "linux_arm64",
+        "linux-x64": "linux_amd64",
+      };
+      const target = targets[`${platform}-${arch}`] ?? "linux_amd64";
+      return `https://github.com/4ier/notion-cli/releases/download/v0.3.0/notion-cli_0.3.0_${target}.tar.gz`;
+    },
+  },
+];

package/server/conversation/adapterRegistry.ts

@@ -0,0 +1,53 @@
+import type { ConversationAdapter } from "./types";
+
+export interface AdapterDefinition {
+  /** Unique harness identifier, e.g. "codex", "claude_code" */
+  id: string;
+
+  /** CLI binary name to probe for availability, e.g. "codex", "claude" */
+  command: string;
+
+  /** Model label → model ID mapping, e.g. { "Opus 4.6": "opus" } */
+  models: Record<string, string>;
+
+  /** Optional: model ID override for cheap title generation */
+  titleModelId?: string;
+
+  /**
+   * Directories (relative to $HOME) where this harness stores global skills.
+   * Each entry is a { dir, label } pair, e.g. { dir: ".claude/skills", label: "Claude Code" }.
+   */
+  globalSkillsDirs?: { dir: string; label: string }[];
+
+  /**
+   * JSON config files (relative to $HOME) that may contain MCP server definitions.
+   * Each entry specifies the file path and the JSON key that holds the server map.
+   * E.g. { path: ".claude.json", key: "mcpServers" } for Claude Code.
+   */
+  mcpConfigFiles?: { path: string; key: string }[];
+
+  /** Build the ConversationAdapter that handles sendTurn for this harness */
+  createAdapter(): ConversationAdapter;
+}
+
+const registry = new Map<string, AdapterDefinition>();
+
+export function registerAdapter(def: AdapterDefinition): void {
+  registry.set(def.id, def);
+}
+
+export function getAdapterDefinition(id: string): AdapterDefinition {
+  const def = registry.get(id);
+  if (!def) {
+    throw new Error(`Unknown adapter: ${id}`);
+  }
+  return def;
+}
+
+export function allAdapterDefinitions(): AdapterDefinition[] {
+  return [...registry.values()];
+}
+
+export function getRegisteredHarnessIds(): string[] {
+  return [...registry.keys()].sort();
+}

package/server/conversation/adapters/claudeAdapter.ts

@@ -0,0 +1,138 @@
+import { existsSync } from "node:fs";
+import { resolve, join } from "node:path";
+import { homedir } from "node:os";
+import type { AdapterSendTurnInput, AdapterSendTurnResult, ConversationAdapter } from "../types";
+import { registerAdapter } from "../adapterRegistry";
+import {
+  runAdapterCommand,
+  withReasoningEffort,
+  readString,
+  readObject,
+  readArray,
+  readBoolean,
+  appendText,
+} from "../adapters";
+
+/**
+ * Tools that mutate files. Blocked in chat mode so the agent can only read.
+ */
+const CHAT_DISALLOWED_TOOLS = ["Edit", "Write", "NotebookEdit"];
+
+const claudeAdapter: ConversationAdapter = {
+  async sendTurn(input: AdapterSendTurnInput): Promise<AdapterSendTurnResult> {
+    const args = buildClaudeArgs(input);
+    return runAdapterCommand({
+      command: "claude",
+      args,
+      cwd: input.cwd,
+      env: input.env,
+      abortSignal: input.abortSignal,
+      onJsonLine: async (line, state) => {
+        const eventType = readString(line, "type");
+
+        if (eventType === "system") {
+          const subtype = readString(line, "subtype");
+          if (subtype === "init") {
+            const sessionId = readString(line, "session_id");
+            if (sessionId) {
+              state.sessionId = sessionId;
+            }
+          }
+          return;
+        }
+
+        if (eventType === "assistant") {
+          const message = readObject(line, "message");
+          const content = readArray(message, "content");
+
+          for (const block of content) {
+            if (typeof block !== "object" || block === null) {
+              continue;
+            }
+
+            const blockType = readString(block, "type");
+            if (blockType === "text") {
+              const text = readString(block, "text") ?? "";
+              if (text) {
+                state.finalText = appendText(state.finalText, text);
+                await input.onEvent({ type: "assistant_text", delta: text });
+              }
+              continue;
+            }
+
+            await input.onEvent({
+              type: "tool_event",
+              name: `assistant.${blockType || "block"}`,
+              payload: block as Record<string, unknown>,
+            });
+          }
+          return;
+        }
+
+        if (eventType === "result") {
+          const isError = Boolean(readBoolean(line, "is_error"));
+          const resultText = readString(line, "result") ?? "";
+          if (resultText && !state.finalText) {
+            state.finalText = resultText;
+          }
+          if (isError) {
+            state.commandError = resultText || "Claude CLI returned an error.";
+          }
+          return;
+        }
+        // Ignore non-tool lifecycle noise (user/result/system echoes).
+      },
+    });
+  },
+};
+
+function buildClaudeArgs(input: AdapterSendTurnInput): string[] {
+  const prompt = withReasoningEffort(input.prompt, input.reasoningEffort);
+  const resolvedCwd = resolve(input.cwd);
+  const args = [
+    "-p",
+    "--output-format",
+    "stream-json",
+    "--verbose",
+    "--allow-dangerously-skip-permissions",
+    "--dangerously-skip-permissions",
+    "--permission-mode",
+    "bypassPermissions",
+    "--add-dir",
+    resolvedCwd,
+    "--model",
+    input.modelId,
+  ];
+
+  if (input.mode === "chat") {
+    args.push("--disallowedTools", CHAT_DISALLOWED_TOOLS.join(","));
+  }
+
+  if (input.sessionId) {
+    const slug = resolvedCwd.replace(/\//g, "-");
+    const sessionFile = join(homedir(), ".claude", "projects", slug, `${input.sessionId}.jsonl`);
+    if (existsSync(sessionFile)) {
+      args.push("--resume", input.sessionId);
+    }
+  }
+
+  args.push("--", prompt);
+  return args;
+}
+
+registerAdapter({
+  id: "claude_code",
+  command: "claude",
+  models: {
+    "Opus 4.6": "opus",
+    "Sonnet 4.6": "sonnet",
+    "Haiku 4.5": "haiku",
+  },
+  titleModelId: "haiku",
+  globalSkillsDirs: [
+    { dir: ".claude/skills", label: "Claude Code" },
+    { dir: ".agents/skills", label: "Agents" },
+  ],
+  mcpConfigFiles: [{ path: ".claude.json", key: "mcpServers" }],
+  createAdapter: () => claudeAdapter,
+});

package/server/conversation/adapters/codexAdapter.ts

@@ -0,0 +1,142 @@
+import { resolve } from "node:path";
+import type { AdapterSendTurnInput, AdapterSendTurnResult, ConversationAdapter } from "../types";
+import { registerAdapter } from "../adapterRegistry";
+import {
+  runAdapterCommand,
+  withReasoningEffort,
+  readString,
+  readObject,
+  appendText,
+} from "../adapters";
+
+const codexAdapter: ConversationAdapter = {
+  async sendTurn(input: AdapterSendTurnInput): Promise<AdapterSendTurnResult> {
+    const args = buildCodexArgs(input);
+    return runAdapterCommand({
+      command: "codex",
+      args,
+      cwd: input.cwd,
+      env: input.env,
+      abortSignal: input.abortSignal,
+      onJsonLine: async (line, state) => {
+        const eventType = readString(line, "type");
+        if (eventType === "thread.started") {
+          const threadId = readString(line, "thread_id");
+          if (threadId) {
+            state.sessionId = threadId;
+          }
+          return;
+        }
+
+        if (eventType === "item.completed") {
+          const item = readObject(line, "item");
+          const itemType = readString(item, "type");
+
+          if (itemType === "agent_message") {
+            const text = readString(item, "text") ?? "";
+            if (text) {
+              state.finalText = appendText(state.finalText, text);
+              await input.onEvent({ type: "assistant_text", delta: text });
+            }
+            return;
+          }
+
+          if (shouldEmitCodexToolEvent(itemType, item)) {
+            await input.onEvent({
+              type: "tool_event",
+              name: `item.${itemType || "unknown"}`,
+              payload: item,
+            });
+          }
+          return;
+        }
+
+        if (eventType === "error" || eventType === "turn.failed") {
+          state.commandError = readString(line, "message") || JSON.stringify(line);
+          return;
+        }
+
+        // Ignore non-tool lifecycle noise like turn.started/turn.completed.
+      },
+    });
+  },
+};
+
+function buildCodexArgs(input: AdapterSendTurnInput): string[] {
+  const prompt = withReasoningEffort(input.prompt, input.reasoningEffort);
+  const resolvedCwd = resolve(input.cwd);
+  const topLevelArgs =
+    input.mode === "chat"
+      ? ["-s", "read-only", "-a", "never", "-C", resolvedCwd]
+      : ["-C", resolvedCwd];
+
+  const execSandboxArgs =
+    input.mode === "chat" ? [] : ["-s", "danger-full-access"];
+
+  if (input.sessionId) {
+    return [
+      ...topLevelArgs,
+      "exec",
+      ...execSandboxArgs,
+      "resume",
+      "--json",
+      "--skip-git-repo-check",
+      "--model",
+      input.modelId,
+      input.sessionId,
+      prompt,
+    ];
+  }
+
+  return [
+    ...topLevelArgs,
+    "exec",
+    ...execSandboxArgs,
+    "--json",
+    "--skip-git-repo-check",
+    "--model",
+    input.modelId,
+    prompt,
+  ];
+}
+
+function shouldEmitCodexToolEvent(
+  itemType: string | null,
+  item: Record<string, unknown>,
+): boolean {
+  if (!itemType) {
+    return false;
+  }
+
+  // Hide reasoning and other verbose metadata events.
+  if (itemType === "reasoning" || itemType === "plan") {
+    return false;
+  }
+
+  if (itemType.includes("tool")) {
+    return true;
+  }
+
+  // Some codex event variants may include command/file ops without "tool" in type.
+  if (typeof item.command === "string") {
+    return true;
+  }
+  if (typeof item.file_path === "string") {
+    return true;
+  }
+
+  return false;
+}
+
+registerAdapter({
+  id: "codex",
+  command: "codex",
+  models: {
+    "GPT-5": "gpt-5",
+    "GPT-5.3-Codex": "gpt-5.3-codex",
+  },
+  globalSkillsDirs: [
+    { dir: ".agents/skills", label: "Codex" },
+  ],
+  createAdapter: () => codexAdapter,
+});