xedoc-cli 0.1.0

package/README.md

@@ -0,0 +1,111 @@
+# xedoc
+
+xedoc is a single React Router Framework Mode app, built with Vite, for managing Codex accounts, chats, chat execution, workspace browsing, and live assistant output.
+
+## What It Does
+
+- Stores users, Codex accounts, chat metadata, runs, and live message projections in a local SQLite database through Prisma.
+- Starts Codex account authentication through the local `codex app-server` JSON-RPC flow.
+- Isolates each Codex account with a separate `CODEX_HOME`.
+- Stores a working directory on each chat so different chats can target different local projects.
+- Executes chat prompts against the selected Codex account and reads settled transcripts back from Codex runtime/session data.
+- Serves the ChatGPT-style web UI and `/api/*` resource routes from one same-origin app.
+- Streams live chat updates through authenticated Socket.IO rooms on `/socket.io`.
+
+## Setup
+
+The easiest local install is the npm CLI:
+
+```bash
+npx xedoc
+```
+
+By default the CLI creates a standalone SQLite database at
+`~/.xedoc/xedoc.db`, prepares the schema, and serves the app at
+`http://127.0.0.1:6354`. Open the app in a browser and set the server password
+on first visit. Use a different database file with:
+
+```bash
+npx xedoc --database-path ~/.local/share/xedoc.db
+```
+
+Common CLI options:
+
+- `--port <port>` changes the web server port.
+- `--workspace-root <path>` changes the directory tree visible to the app.
+- `--accounts-home <path>` changes where Codex account state is stored.
+- `--database-path <path>` changes where the SQLite database is stored.
+- `--skip-setup` skips SQLite schema setup.
+
+For repository development:
+
+```bash
+pnpm install
+cp .env.example .env
+pnpm prisma:generate
+pnpm db:setup
+pnpm dev
+```
+
+On first visit, the web app asks you to set the server password and stores a
+hashed password plus token signing secret in the SQLite database. Later browser
+sessions exchange that password for a bearer token, then store the token,
+browser user id, and active account id in local storage.
+
+The default `DATABASE_URL` uses a SQLite file under `.xedoc/` in the
+project. Set `DATABASE_URL=file:/absolute/path/to/xedoc.db` to use a
+specific database file.
+
+## Scripts
+
+- `pnpm dev` starts the React Router dev server.
+- `pnpm build` builds the app.
+- `pnpm start` serves the production React Router build through `server/index.mjs` and attaches Socket.IO.
+- `pnpm db:setup` creates or updates the local SQLite schema.
+- `pnpm prisma:generate` regenerates Prisma Client.
+- `pnpm run publish` publishes the package to npm with public access. npm runs `prepack`, which builds the production bundle first.
+- `pnpm run publish:dry-run` checks the npm package contents without publishing.
+
+## npm Releases
+
+Package releases are published by GitHub Actions when a tag matching `v*` is
+pushed. The workflow uses npm trusted publishing, so configure the package on
+npmjs.com with this GitHub repository and the workflow file
+`.github/workflows/npm-publish.yml` before pushing the first release tag.
+
+## Codex Account Isolation
+
+Each Codex account runs as its own local `codex app-server` process. The server sets `CODEX_HOME` per account so auth files, config, sessions, cache, and other Codex state stay under:
+
+```text
+~/.xedoc/accounts/<accountId>
+```
+
+Set `CODEX_ACCOUNTS_HOME` to change the base directory. This isolates Codex account state only; Codex still runs as the same host user and can access whatever that user can access.
+
+Set `CODEX_WORKSPACE_ROOT` to the directory the web app can browse for chat
+working directories. Local development defaults to the current user's home
+directory, for example `/home/ubuntu`.
+
+## API Entry Points
+
+- `GET /health`
+- `GET /api/auth/status`
+- `POST /api/auth/exchange`
+- `GET /api/auth/session`
+- `POST /api/users`
+- `GET /api/accounts`
+- `POST /api/accounts`
+- `GET /api/accounts/:accountId`
+- `PATCH /api/accounts/:accountId`
+- `DELETE /api/accounts/:accountId`
+- `POST /api/accounts/:accountId/authenticate`
+- `POST /api/accounts/:accountId/authenticate/callback`
+- `GET /api/chats`
+- `POST /api/chats`
+- `GET /api/chats/:chatId`
+- `PATCH /api/chats/:chatId`
+- `DELETE /api/chats/:chatId`
+- `GET /api/chats/:chatId/messages`
+- `POST /api/chats/:chatId/messages`
+- `GET /api/workspaces/directories`

package/bin/xedoc.mjs

@@ -0,0 +1,233 @@
+#!/usr/bin/env node
+import { spawn } from "node:child_process"
+import { mkdir, readFile } from "node:fs/promises"
+import { homedir } from "node:os"
+import { dirname, join, resolve } from "node:path"
+import { fileURLToPath } from "node:url"
+import { createRequire } from "node:module"
+
+const packageRoot = resolve(dirname(fileURLToPath(import.meta.url)), "..")
+const require = createRequire(import.meta.url)
+const packageJson = JSON.parse(
+  await readFile(join(packageRoot, "package.json"), "utf8"),
+)
+
+const options = parseArgs(process.argv.slice(2))
+if (options.help) {
+  printHelp()
+  process.exit(0)
+}
+if (options.version) {
+  console.log(packageJson.version)
+  process.exit(0)
+}
+
+const appHome = resolveHomePath(
+  options.home ?? process.env.XEDOC_HOME ?? "~/.xedoc",
+)
+await mkdir(appHome, { recursive: true, mode: 0o700 })
+
+const port = options.port ?? process.env.PORT ?? "6354"
+const host = options.host ?? process.env.HOST ?? "127.0.0.1"
+const accountsHome = resolveHomePath(
+  options.accountsHome ??
+    process.env.CODEX_ACCOUNTS_HOME ??
+    join(appHome, "accounts"),
+)
+const workspaceRoot = resolveHomePath(
+  options.workspaceRoot ?? process.env.CODEX_WORKSPACE_ROOT ?? homedir(),
+)
+const databasePath = resolveHomePath(
+  options.databasePath ??
+    process.env.XEDOC_DATABASE ??
+    join(appHome, "xedoc.db"),
+)
+await mkdir(dirname(databasePath), { recursive: true, mode: 0o700 })
+const databaseUrl =
+  options.databaseUrl ??
+  process.env.DATABASE_URL ??
+  `file:${databasePath}`
+
+const codexBin = require.resolve("@openai/codex/bin/codex.js")
+const env = {
+  ...process.env,
+  CODEX_ACCOUNTS_HOME: accountsHome,
+  CODEX_ARGS: options.codexArgs ?? process.env.CODEX_ARGS ?? `${codexBin} app-server`,
+  CODEX_COMMAND: options.codexCommand ?? process.env.CODEX_COMMAND ?? process.execPath,
+  CODEX_WORKSPACE_ROOT: workspaceRoot,
+  DATABASE_URL: databaseUrl,
+  HOST: host,
+  NODE_ENV: "production",
+  PORT: port,
+}
+
+await mkdir(accountsHome, { recursive: true, mode: 0o700 })
+if (!options.skipPrismaGenerate) {
+  await runPrisma(["generate"], env)
+}
+if (!options.skipSetup) {
+  await setupSqliteDatabase(env)
+}
+
+const url = `http://${host === "0.0.0.0" ? "localhost" : host}:${port}`
+console.log(`xedoc: ${url}`)
+console.log("Set the server password in your browser on first visit.")
+console.log(`Workspace root: ${workspaceRoot}`)
+console.log("Press Ctrl+C to stop.")
+
+await runServer(env)
+
+function parseArgs(argv) {
+  const parsed = {}
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index]
+    if (arg === "--help" || arg === "-h") {
+      parsed.help = true
+    } else if (arg === "--version" || arg === "-v") {
+      parsed.version = true
+    } else if (arg === "--skip-setup") {
+      parsed.skipSetup = true
+    } else if (arg === "--skip-prisma-generate") {
+      parsed.skipPrismaGenerate = true
+    } else if (arg.startsWith("--")) {
+      const [name, inlineValue] = arg.split("=", 2)
+      const value = inlineValue ?? argv[++index]
+      if (!value || value.startsWith("--")) {
+        fail(`${name} requires a value.`)
+      }
+      assignOption(parsed, name, value)
+    } else {
+      fail(`Unknown argument: ${arg}`)
+    }
+  }
+  return parsed
+}
+
+function assignOption(parsed, name, value) {
+  switch (name) {
+    case "--accounts-home":
+      parsed.accountsHome = value
+      return
+    case "--codex-args":
+      parsed.codexArgs = value
+      return
+    case "--codex-command":
+      parsed.codexCommand = value
+      return
+    case "--database-url":
+      parsed.databaseUrl = value
+      return
+    case "--database-path":
+      parsed.databasePath = value
+      return
+    case "--home":
+      parsed.home = value
+      return
+    case "--host":
+      parsed.host = value
+      return
+    case "--port":
+      parsed.port = value
+      return
+    case "--workspace-root":
+      parsed.workspaceRoot = value
+      return
+    default:
+      fail(`Unknown option: ${name}`)
+  }
+}
+
+async function runPrisma(args, env) {
+  await run(process.execPath, [
+    require.resolve("prisma/build/index.js"),
+    ...args,
+    "--schema",
+    join(packageRoot, "prisma/schema.prisma"),
+  ], {
+    cwd: packageRoot,
+    env,
+    stdio: "inherit",
+  })
+}
+
+async function runServer(env) {
+  await run(process.execPath, [join(packageRoot, "server/index.mjs")], {
+    cwd: packageRoot,
+    env,
+    stdio: "inherit",
+  })
+}
+
+async function setupSqliteDatabase(env) {
+  const previousDatabaseUrl = process.env.DATABASE_URL
+  process.env.DATABASE_URL = env.DATABASE_URL
+  try {
+    const { setupSqliteDatabase } = await import(
+      join(packageRoot, "server/sqlite-setup.mjs")
+    )
+    await setupSqliteDatabase()
+  } finally {
+    if (previousDatabaseUrl === undefined) {
+      delete process.env.DATABASE_URL
+    } else {
+      process.env.DATABASE_URL = previousDatabaseUrl
+    }
+  }
+}
+
+function run(command, args, options) {
+  return new Promise((resolveRun, rejectRun) => {
+    const child = spawn(command, args, options)
+    const forwardSigint = () => child.kill("SIGINT")
+    const forwardSigterm = () => child.kill("SIGTERM")
+    process.once("SIGINT", forwardSigint)
+    process.once("SIGTERM", forwardSigterm)
+    child.on("exit", (code, signal) => {
+      process.removeListener("SIGINT", forwardSigint)
+      process.removeListener("SIGTERM", forwardSigterm)
+      if (code === 0 || signal) {
+        resolveRun()
+      } else {
+        rejectRun(new Error(`${command} exited with code ${code}`))
+      }
+    })
+    child.on("error", rejectRun)
+  })
+}
+
+function resolveHomePath(path) {
+  if (path === "~") {
+    return homedir()
+  }
+  if (path.startsWith("~/")) {
+    return join(homedir(), path.slice(2))
+  }
+  return resolve(path)
+}
+
+function fail(message) {
+  console.error(message)
+  process.exit(1)
+}
+
+function printHelp() {
+  console.log(`xedoc ${packageJson.version}
+
+Usage:
+  npx xedoc [options]
+
+Options:
+  --port <port>                 Web server port. Defaults to 6354.
+  --host <host>                 Web server host. Defaults to 127.0.0.1.
+  --workspace-root <path>       Directory tree visible in the app. Defaults to your home directory.
+  --accounts-home <path>        Codex account state directory. Defaults to ~/.xedoc/accounts.
+  --database-path <path>        SQLite database path. Defaults to ~/.xedoc/xedoc.db.
+  --database-url <url>          SQLite DATABASE_URL. Defaults to file:<database-path>.
+  --skip-setup                  Do not create the SQLite database schema.
+  --codex-command <command>     Codex command used for new accounts.
+  --codex-args <args>           Codex command arguments used for new accounts.
+  --home <path>                 App data directory. Defaults to ~/.xedoc.
+  --help                        Show this help.
+  --version                     Print the package version.
+`)
+}

package/build/client/assets/app-layout-C1QtSnIO.js

@@ -0,0 +1 @@
+import{j as r,t as s}from"./jsx-runtime-B9QlDcuB.js";import{t}from"./app-shell-Bcxy4tS4.js";var a=s(),o=r(function(){return(0,a.jsx)(t,{})});export{o as default};