plotlink-ows 1.0.33 → 1.2.95

package/README.md

@@ -256,9 +256,13 @@ PlotLink supports both human writers and AI agent writers via [ERC-8004](https:/
 
 ## Development
 
+Use Node 20 with npm 10. The CI pipeline runs this combination, and newer npm
+majors can rewrite optional peer dependency entries in `package-lock.json`.
+
 ```bash
 git clone https://github.com/realproject7/plotlink-ows.git
 cd plotlink-ows
+nvm use
 npm install
 npm run app:dev      # Start local writer app (Hono + Vite dev)
 npm run app:build    # Build frontend for production

package/app/lib/active-wallet.ts

@@ -0,0 +1,260 @@
+import type { WalletInfo } from "../../lib/ows/types";
+import { getBaseAddress, listAgentWallets } from "../../lib/ows/wallet";
+import { db } from "../db";
+
+const ACTIVE_WALLET_SETTING_KEY = "activeOwsWallet.v1";
+const PLOTLINK_WALLET_PREFIX = "plotlink-writer";
+
+export interface StoredWalletSelection {
+  walletId?: string;
+  name?: string;
+  address?: string;
+  source: "ows";
+  label?: string;
+}
+
+export interface WalletChoice {
+  walletId?: string;
+  name: string;
+  address?: string;
+  normalizedAddress?: string;
+  source: "ows";
+  label: string;
+  recognized: boolean;
+  active: boolean;
+}
+
+export interface ActiveWallet {
+  wallet: WalletInfo;
+  walletId?: string;
+  name: string;
+  address: string;
+  normalizedAddress: string;
+  source: "ows";
+  label: string;
+}
+
+export interface PublicActiveWallet {
+  walletId?: string;
+  name: string;
+  address: string;
+  normalizedAddress: string;
+  source: "ows";
+  label: string;
+}
+
+export interface ActiveWalletResolution {
+  activeWallet: ActiveWallet | null;
+  wallets: WalletChoice[];
+  selectionRequired: boolean;
+  error?: string;
+}
+
+function normalizeAddress(address: string | undefined): string | undefined {
+  const trimmed = address?.trim();
+  return trimmed ? trimmed.toLowerCase() : undefined;
+}
+
+function getWalletId(wallet: WalletInfo): string | undefined {
+  const maybeId = (wallet as WalletInfo & { id?: unknown }).id;
+  return typeof maybeId === "string" && maybeId.trim() ? maybeId : undefined;
+}
+
+function toWalletChoice(wallet: WalletInfo, activeSelection?: StoredWalletSelection): WalletChoice {
+  const address = getBaseAddress(wallet);
+  const normalizedAddress = normalizeAddress(address);
+  const walletId = getWalletId(wallet);
+  const recognized = wallet.name.startsWith(PLOTLINK_WALLET_PREFIX);
+  return {
+    walletId,
+    name: wallet.name,
+    address: normalizedAddress,
+    normalizedAddress,
+    source: "ows",
+    label: recognized ? "PlotLink writer wallet" : "OWS wallet",
+    recognized,
+    active: matchesSelection(wallet, address, activeSelection),
+  };
+}
+
+function matchesSelection(wallet: WalletInfo, address: string | undefined, selection: StoredWalletSelection | null | undefined): boolean {
+  if (!selection) return false;
+  const walletId = getWalletId(wallet);
+  const normalizedAddress = normalizeAddress(address);
+  const selectedAddress = normalizeAddress(selection.address);
+  if (selection.walletId && walletId && selection.walletId === walletId) return true;
+  if (selectedAddress && normalizedAddress && selectedAddress === normalizedAddress) return true;
+  if (selection.name && selection.name === wallet.name) return true;
+  return false;
+}
+
+function storedSelectionFor(wallet: WalletInfo): StoredWalletSelection {
+  const address = normalizeAddress(getBaseAddress(wallet));
+  return {
+    walletId: getWalletId(wallet),
+    name: wallet.name,
+    address,
+    source: "ows",
+    label: wallet.name.startsWith(PLOTLINK_WALLET_PREFIX) ? "PlotLink writer wallet" : "OWS wallet",
+  };
+}
+
+async function readStoredSelection(): Promise<StoredWalletSelection | null> {
+  try {
+    const row = await db.setting.findUnique({ where: { key: ACTIVE_WALLET_SETTING_KEY } });
+    if (!row?.value) return null;
+    const parsed = JSON.parse(row.value) as Partial<StoredWalletSelection>;
+    if (parsed.source !== "ows") return null;
+    return {
+      walletId: typeof parsed.walletId === "string" ? parsed.walletId : undefined,
+      name: typeof parsed.name === "string" ? parsed.name : undefined,
+      address: normalizeAddress(parsed.address),
+      source: "ows",
+      label: typeof parsed.label === "string" ? parsed.label : undefined,
+    };
+  } catch {
+    return null;
+  }
+}
+
+async function writeStoredSelection(selection: StoredWalletSelection): Promise<void> {
+  try {
+    await db.setting.upsert({
+      where: { key: ACTIVE_WALLET_SETTING_KEY },
+      create: { key: ACTIVE_WALLET_SETTING_KEY, value: JSON.stringify(selection) },
+      update: { value: JSON.stringify(selection) },
+    });
+  } catch {
+    // The app can still operate in legacy single-wallet mode if persistence is
+    // temporarily unavailable; signing never depends on this write succeeding.
+  }
+}
+
+function findSelectedWallet(wallets: WalletInfo[], selection: StoredWalletSelection | null): WalletInfo | null {
+  if (!selection) return null;
+  return wallets.find((wallet) => matchesSelection(wallet, getBaseAddress(wallet), selection)) ?? null;
+}
+
+function toActiveWallet(wallet: WalletInfo): ActiveWallet | null {
+  const address = normalizeAddress(getBaseAddress(wallet));
+  if (!address) return null;
+  return {
+    wallet,
+    walletId: getWalletId(wallet),
+    name: wallet.name,
+    address,
+    normalizedAddress: address,
+    source: "ows",
+    label: wallet.name.startsWith(PLOTLINK_WALLET_PREFIX) ? "PlotLink writer wallet" : "OWS wallet",
+  };
+}
+
+export async function listWalletChoices(): Promise<WalletChoice[]> {
+  const wallets = listAgentWallets();
+  const selection = await readStoredSelection();
+  return wallets.map((wallet) => toWalletChoice(wallet, selection));
+}
+
+export async function resolveActiveWallet(): Promise<ActiveWalletResolution> {
+  const wallets = listAgentWallets();
+  const selection = await readStoredSelection();
+  const storedWallet = findSelectedWallet(wallets, selection);
+  const activeFromStored = storedWallet ? toActiveWallet(storedWallet) : null;
+  if (activeFromStored) {
+    return {
+      activeWallet: activeFromStored,
+      wallets: wallets.map((wallet) => toWalletChoice(wallet, storedSelectionFor(storedWallet))),
+      selectionRequired: false,
+    };
+  }
+
+  const evmWallets = wallets.filter((wallet) => Boolean(getBaseAddress(wallet)));
+  const recognizedWallets = evmWallets.filter((wallet) => wallet.name.startsWith(PLOTLINK_WALLET_PREFIX));
+  const autoSelected = recognizedWallets.length === 1
+    ? recognizedWallets[0]
+    : recognizedWallets.length === 0 && evmWallets.length === 1
+      ? evmWallets[0]
+      : null;
+
+  if (autoSelected) {
+    const stored = storedSelectionFor(autoSelected);
+    await writeStoredSelection(stored);
+    return {
+      activeWallet: toActiveWallet(autoSelected),
+      wallets: wallets.map((wallet) => toWalletChoice(wallet, stored)),
+      selectionRequired: false,
+    };
+  }
+
+  const choices = wallets.map((wallet) => toWalletChoice(wallet, null));
+  const hasSelectableWallets = evmWallets.length > 0;
+  return {
+    activeWallet: null,
+    wallets: choices,
+    selectionRequired: hasSelectableWallets,
+    error: hasSelectableWallets
+      ? "Multiple OWS wallets found. Select an active wallet before publishing or signing."
+      : "No OWS wallet found",
+  };
+}
+
+export async function selectActiveWallet(input: { walletId?: string; name?: string; address?: string }): Promise<ActiveWalletResolution> {
+  const wallets = listAgentWallets();
+  const normalizedInputAddress = normalizeAddress(input.address);
+  const selected = wallets.find((wallet) => {
+    const walletId = getWalletId(wallet);
+    const address = normalizeAddress(getBaseAddress(wallet));
+    if (input.walletId && walletId && walletId === input.walletId) return true;
+    if (normalizedInputAddress && address && address === normalizedInputAddress) return true;
+    if (input.name && wallet.name === input.name) return true;
+    return false;
+  });
+
+  if (!selected) {
+    return {
+      activeWallet: null,
+      wallets: wallets.map((wallet) => toWalletChoice(wallet, null)),
+      selectionRequired: true,
+      error: "Selected OWS wallet was not found",
+    };
+  }
+
+  const activeWallet = toActiveWallet(selected);
+  if (!activeWallet) {
+    return {
+      activeWallet: null,
+      wallets: wallets.map((wallet) => toWalletChoice(wallet, null)),
+      selectionRequired: true,
+      error: "Selected OWS wallet has no EVM address",
+    };
+  }
+
+  const stored = storedSelectionFor(selected);
+  await writeStoredSelection(stored);
+  return {
+    activeWallet,
+    wallets: wallets.map((wallet) => toWalletChoice(wallet, stored)),
+    selectionRequired: false,
+  };
+}
+
+export function nextPlotlinkWalletName(wallets: WalletInfo[]): string {
+  const names = new Set(wallets.map((wallet) => wallet.name));
+  if (!names.has(PLOTLINK_WALLET_PREFIX)) return PLOTLINK_WALLET_PREFIX;
+  for (let index = 2; index < 1000; index += 1) {
+    const name = `${PLOTLINK_WALLET_PREFIX}-${index}`;
+    if (!names.has(name)) return name;
+  }
+  return `${PLOTLINK_WALLET_PREFIX}-${Date.now()}`;
+}
+
+export function toPublicActiveWallet(wallet: ActiveWallet): PublicActiveWallet {
+  return {
+    walletId: wallet.walletId,
+    name: wallet.name,
+    address: wallet.address,
+    normalizedAddress: wallet.normalizedAddress,
+    source: wallet.source,
+    label: wallet.label,
+  };
+}

package/app/lib/agent-command.ts

@@ -0,0 +1,85 @@
+import type { AgentProvider } from "../routes/stories";
+
+/**
+ * Pure construction of a terminal agent's CLI invocation as argv.
+ *
+ * This module performs NO fs/pty/env/network access so command building is
+ * fully unit-testable. It returns `{ command, args }` (the binary + argv).
+ *
+ * Claude (KEEP BYTE-IDENTICAL with the legacy inline behavior):
+ *   - fresh:  `claude --session-id <newSessionId>`
+ *   - resume: `claude --resume <sessionId>`
+ *   - bypass: append `--dangerously-skip-permissions`
+ *
+ * Codex (net-new). Both fresh AND resume carry the story cwd (`--cd`) and the
+ * `image_generation` capability — a resumed cartoon session needs the same
+ * working directory and image-gen feature as a fresh one (see #265):
+ *   - fresh:  `codex --enable image_generation --cd <storyDir>`
+ *   - resume: `codex resume <sessionId> --enable image_generation --cd <storyDir>`
+ *             (subcommand style) when an id is stored, otherwise
+ *             `codex resume --last --enable image_generation --cd <storyDir>`.
+ *             NEVER `--resume <id>`.
+ *   - bypass: append `--dangerously-bypass-approvals-and-sandbox`
+ *
+ * Claude-only and Codex-only flags are never mixed across providers.
+ */
+export type AgentMode = "normal" | "bypass";
+
+export interface BuildAgentCommandOptions {
+  provider: AgentProvider;
+  mode: AgentMode;
+  resume: boolean;
+  /** Stored resume id (Claude UUID / Codex session id), or null. */
+  sessionId: string | null;
+  /** Freshly generated UUID used for a brand-new Claude session. */
+  newSessionId: string;
+  /** Absolute story working directory (used by Codex `--cd`). */
+  storyDir: string;
+}
+
+export interface AgentCommand {
+  command: string;
+  args: string[];
+}
+
+export function buildAgentCommand(opts: BuildAgentCommandOptions): AgentCommand {
+  if (opts.provider === "codex") {
+    return buildCodexCommand(opts);
+  }
+  return buildClaudeArgs(opts);
+}
+
+function buildClaudeArgs(opts: BuildAgentCommandOptions): AgentCommand {
+  const args: string[] = [];
+  // Resume only when requested AND a stored id exists; else fresh session.
+  if (opts.resume && opts.sessionId) {
+    args.push("--resume", opts.sessionId);
+  } else {
+    args.push("--session-id", opts.newSessionId);
+  }
+  if (opts.mode === "bypass") {
+    args.push("--dangerously-skip-permissions");
+  }
+  return { command: "claude", args };
+}
+
+function buildCodexCommand(opts: BuildAgentCommandOptions): AgentCommand {
+  const args: string[] = [];
+  if (opts.resume) {
+    // Codex resume is a subcommand (never `--resume <id>`). The subcommand and
+    // its target come first, then the capability/cwd flags.
+    if (opts.sessionId) {
+      args.push("resume", opts.sessionId);
+    } else {
+      args.push("resume", "--last");
+    }
+  }
+  // Both fresh and resume need the image-generation capability and the story
+  // cwd so a resumed cartoon session lands in the right directory with image
+  // generation enabled (not just whatever global session `--last` would pick).
+  args.push("--enable", "image_generation", "--cd", opts.storyDir);
+  if (opts.mode === "bypass") {
+    args.push("--dangerously-bypass-approvals-and-sandbox");
+  }
+  return { command: "codex", args };
+}

package/app/lib/agent-readiness.ts

@@ -0,0 +1,133 @@
+// Agent (CLI) readiness detection.
+//
+// This module is pure: every shell interaction goes through an injected `run`
+// function so it can be unit-tested without spawning processes. The route layer
+// supplies a real `run` that shells out via the user's login shell, and stamps
+// the `checkedAt` timestamp (kept OUT of this pure function so it stays
+// deterministic/testable — no clocks here).
+//
+// Codex image-generation detection parses the structured `codex features list`
+// output rather than guessing from generic `--help` text. See
+// `probeAgentReadiness` for the exact parsing rules.
+
+export type ImageGenStatus = "enabled" | "disabled" | "unknown";
+
+// Codex auth/login hint. "ok" when `codex features list` could actually be read
+// (so we trust the imageGeneration verdict); "unknown" when Codex is installed
+// but its capabilities couldn't be read — commonly a logged-out / unclear-auth
+// state. Best-effort and conservative: default "unknown", never blocks fiction.
+export type AuthStatus = "ok" | "unknown";
+
+export interface AgentReadiness {
+  claude: { installed: boolean };
+  codex: { installed: boolean; version: string | null; imageGeneration: ImageGenStatus; auth: AuthStatus };
+  checkedAt: number; // epoch ms — added by the route, NOT by the pure probe.
+}
+
+/**
+ * Distinct "you may not be logged in to Codex" signal (#263): Codex is installed
+ * but `codex features list` couldn't be read, so the actionable next step is a
+ * Codex login (outside OWS), NOT enabling a feature. Pure + shared so the New
+ * Story flow, the terminal launch-blocked panel, and Settings stay consistent.
+ */
+export function isCodexAuthUnclear(
+  readiness: Pick<AgentReadiness, "codex"> | null | undefined,
+): boolean {
+  return !!readiness && readiness.codex.installed && readiness.codex.auth === "unknown";
+}
+
+/** Operator-facing copy for the auth-unclear case (#263). Shared across surfaces. */
+export const CODEX_AUTH_UNCLEAR_MESSAGE =
+  "Codex is installed but its capabilities couldn't be read — you may need to log in to Codex (resolve outside OWS), then re-check.";
+
+/** First non-empty, trimmed line of a command's stdout (or null). */
+function firstNonEmptyTrimmedLine(stdout: string): string | null {
+  for (const raw of stdout.split("\n")) {
+    const line = raw.trim();
+    if (line.length > 0) return line;
+  }
+  return null;
+}
+
+/**
+ * Determine the effective image_generation state from a single matched line of
+ * `codex features list` output.
+ *
+ * Rules:
+ *  - "enabled" when the line shows a truthy state: `true`, `enabled`, `on`, or
+ *    a trailing check mark (✓).
+ *  - "disabled" when the line shows a falsy state: `false`, `disabled`, `off`.
+ *  - "unknown" when image_generation is present but the state is unparseable.
+ *
+ * Truthy is checked before falsy is irrelevant because a single line never
+ * carries both; we test falsy first to avoid `disabled` matching a substring of
+ * something truthy (there is none, but order keeps intent explicit).
+ */
+function parseImageGenLine(line: string): ImageGenStatus {
+  const l = line.toLowerCase();
+  // Falsy markers.
+  if (/\b(false|disabled|off)\b/.test(l)) return "disabled";
+  // Truthy markers (word states or a trailing check mark).
+  if (/\b(true|enabled|on)\b/.test(l) || /✓/.test(line)) return "enabled";
+  return "unknown";
+}
+
+/**
+ * Probe local agent CLIs. Pure: all shelling-out is injected via `run`.
+ * Returns everything except `checkedAt` (the route stamps that with Date.now()).
+ *
+ * Checks performed:
+ *  - claude.installed: `claude --version` succeeds.
+ *  - codex.installed:  `codex --version` succeeds.
+ *  - codex.version:    first non-empty line of `codex --version` stdout (or null).
+ *  - codex.imageGeneration: parsed from `codex features list`:
+ *      * codex not installed                 -> "unknown"
+ *      * `codex features list` fails / empty  -> "unknown"
+ *      * line mentions image_generation:      -> parseImageGenLine(...)
+ *      * successful listing WITHOUT the line  -> "disabled"
+ *        (a real `features list` that omits image_generation means the feature
+ *        isn't available)
+ */
+export async function probeAgentReadiness(
+  run: (cmd: string) => Promise<{ ok: boolean; stdout: string }>,
+): Promise<Omit<AgentReadiness, "checkedAt">> {
+  const claudeInstalled = (await run("claude --version")).ok;
+
+  const codexVersionResult = await run("codex --version");
+  const codexInstalled = codexVersionResult.ok;
+  const codexVersion = codexInstalled
+    ? firstNonEmptyTrimmedLine(codexVersionResult.stdout) || null
+    : null;
+
+  let imageGeneration: ImageGenStatus = "unknown";
+  // Conservative default: until we can actually read `codex features list`, treat
+  // auth as unclear (covers not-installed and logged-out states alike).
+  let auth: AuthStatus = "unknown";
+
+  if (codexInstalled) {
+    const features = await run("codex features list");
+    if (features.ok && features.stdout.trim().length > 0) {
+      // A readable feature listing means Codex auth/login is working.
+      auth = "ok";
+      // Accept either `image_generation` or `image-generation` naming.
+      const matchLine = features.stdout
+        .split("\n")
+        .find((line) => {
+          const l = line.toLowerCase();
+          return l.includes("image_generation") || l.includes("image-generation");
+        });
+      if (matchLine) {
+        imageGeneration = parseImageGenLine(matchLine);
+      } else {
+        // Successful listing that never mentions image_generation => not available.
+        imageGeneration = "disabled";
+      }
+    }
+    // else: command failed or empty -> stays "unknown".
+  }
+
+  return {
+    claude: { installed: claudeInstalled },
+    codex: { installed: codexInstalled, version: codexVersion, imageGeneration, auth },
+  };
+}

package/app/lib/apply-schema.ts

@@ -0,0 +1,55 @@
+import fs from "fs";
+
+/**
+ * Local SQLite schema setup WITHOUT the native Prisma schema-engine (#484).
+ *
+ * The installed `plotlink-ows` package must bring its SQLite schema up at
+ * startup, but `prisma db push` spawns a platform-specific schema-engine binary
+ * that fails to start in some packed prod-only installs (an empty
+ * "Schema engine error:" on macOS arm64). The Prisma *client* the app already
+ * uses runs on the library query engine — a different, reliably-present engine —
+ * and can execute the DDL directly via `$executeRawUnsafe`.
+ *
+ * So we ship the canonical DDL as `app/prisma/schema.sql` (generated from
+ * `schema.prisma` with `npm run prisma:sql`) and apply it through the client.
+ */
+
+/**
+ * Split a committed `.sql` file into individual executable statements, dropping
+ * `-- ...` comment lines and blanks. Our DDL is a small, controlled grammar
+ * (CREATE TABLE / CREATE [UNIQUE] INDEX) with no semicolons inside values, so a
+ * `;`-split is safe here.
+ */
+export function parseSqlStatements(sql: string): string[] {
+  return sql
+    .split(";")
+    .map((chunk) =>
+      chunk
+        .split("\n")
+        .filter((line) => !line.trim().startsWith("--"))
+        .join("\n")
+        .trim(),
+    )
+    .filter((stmt) => stmt.length > 0);
+}
+
+/**
+ * Rewrite a CREATE statement to be idempotent so applying the schema on an
+ * already-initialized database is a no-op (the app applies it on every startup).
+ * Only the CREATE TABLE / CREATE [UNIQUE] INDEX forms our schema emits are
+ * rewritten; anything else is returned unchanged.
+ */
+export function makeIdempotent(statement: string): string {
+  return statement
+    .replace(/^CREATE TABLE\s+(?!IF NOT EXISTS)/i, "CREATE TABLE IF NOT EXISTS ")
+    .replace(
+      /^CREATE\s+(UNIQUE\s+)?INDEX\s+(?!IF NOT EXISTS)/i,
+      (_match, unique) => `CREATE ${unique ? "UNIQUE " : ""}INDEX IF NOT EXISTS `,
+    );
+}
+
+/** Read the committed schema DDL and return idempotent, ready-to-execute statements. */
+export function loadSchemaStatements(schemaSqlPath: string): string[] {
+  const sql = fs.readFileSync(schemaSqlPath, "utf8");
+  return parseSqlStatements(sql).map(makeIdempotent);
+}