@gmickel/gno 1.24.0 → 1.25.1

package/src/serve/public/index.html

@@ -4,6 +4,7 @@
     <meta charset="UTF-8" />
     <base href="/" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <meta name="referrer" content="no-referrer" />
     <title>GNO - Local Knowledge Index</title>
     <link rel="stylesheet" href="./globals.built.css" />
   </head>

package/src/serve/public/lib/clipper-approval.ts

@@ -0,0 +1,206 @@
+const PAIR_ID = /^[a-f0-9]{64}$/u;
+const PAIRING_CODE = /^\d{8}$/u;
+const TOKEN = /^[a-f0-9]{64}$/u;
+const EXTENSION_ORIGIN = /^chrome-extension:\/\/[a-p]{32}$/u;
+const KNOWN_ERROR_CODES = new Set([
+  "CLIPPER_ABORTED",
+  "CLIPPER_BODY_TOO_LARGE",
+  "CLIPPER_BUSY",
+  "CLIPPER_FORBIDDEN",
+  "CLIPPER_INVALID_JSON",
+  "CLIPPER_RATE_LIMITED",
+  "CLIPPER_UNAUTHORIZED",
+  "CLIPPER_PAIRING_UNAVAILABLE",
+  "CLIPPER_CSRF",
+  "CLIPPER_INVALID_REQUEST",
+  "CLIPPER_PAIR_NOT_FOUND",
+  "CLIPPER_PAIR_EXPIRED",
+  "CLIPPER_PAIR_INVALID_CODE",
+  "CLIPPER_PAIR_ALREADY_USED",
+  "CLIPPER_PREVIEW_MISMATCH",
+  "CLIPPER_PREVIEW_REQUIRED",
+  "CLIPPER_IDEMPOTENCY_PENDING",
+  "CLIPPER_IDEMPOTENCY_CONFLICT",
+  "CLIPPER_IDEMPOTENCY_RECOVERY_CONFLICT",
+  "CLIPPER_IDEMPOTENCY_GRANT_INACTIVE",
+  "CLIPPER_CAPTURE_FAILED",
+  "NOT_FOUND",
+  "RUNTIME",
+  "VALIDATION",
+]);
+
+export interface ClipperPairLaunch {
+  pairId: string | null;
+  valid: boolean;
+}
+
+export interface ClipperApproval {
+  origin: string;
+  expiresAt: string;
+}
+
+export class ClipperApprovalError extends Error {
+  readonly code: string;
+  readonly retryable: boolean;
+
+  constructor(code: string, message: string, retryable = false) {
+    super(message);
+    this.name = "ClipperApprovalError";
+    this.code = code;
+    this.retryable = retryable;
+  }
+}
+
+const isRecord = (value: unknown): value is Record<string, unknown> =>
+  value !== null && typeof value === "object" && !Array.isArray(value);
+
+const hasExactKeys = (
+  value: Record<string, unknown>,
+  keys: readonly string[]
+): boolean => {
+  const actual = Object.keys(value).sort();
+  const expected = [...keys].sort();
+  return (
+    actual.length === expected.length &&
+    actual.every((key, index) => key === expected[index])
+  );
+};
+
+const isDateTime = (value: unknown): value is string =>
+  typeof value === "string" &&
+  Number.isFinite(Date.parse(value)) &&
+  value.includes("T");
+
+export const consumeClipperPairLaunch = (
+  location: Pick<Location, "pathname" | "search" | "hash">,
+  history: Pick<History, "replaceState">
+): ClipperPairLaunch => {
+  if (location.pathname !== "/clipper/pair") {
+    return { pairId: null, valid: false };
+  }
+  const match =
+    location.search === ""
+      ? /^#pairId=(?<pairId>[a-f0-9]{64})$/u.exec(location.hash)
+      : null;
+  history.replaceState({}, "", "/clipper/pair");
+  const pairId = match?.groups?.pairId ?? null;
+  return { pairId, valid: pairId !== null };
+};
+
+const parseError = (value: unknown): ClipperApprovalError | null => {
+  if (
+    !isRecord(value) ||
+    !hasExactKeys(value, ["error"]) ||
+    !isRecord(value.error) ||
+    !hasExactKeys(value.error, ["code", "message"]) ||
+    typeof value.error.code !== "string" ||
+    !KNOWN_ERROR_CODES.has(value.error.code) ||
+    typeof value.error.message !== "string" ||
+    value.error.message.length === 0
+  ) {
+    return null;
+  }
+  return new ClipperApprovalError(
+    value.error.code,
+    value.error.message,
+    value.error.code === "CLIPPER_PAIR_INVALID_CODE"
+  );
+};
+
+const readJson = async (response: Response): Promise<unknown> => {
+  if (
+    !(response.headers.get("content-type") ?? "").includes("application/json")
+  ) {
+    throw new ClipperApprovalError(
+      "CLIPPER_INVALID_RESPONSE",
+      "GNO returned a non-JSON pairing response."
+    );
+  }
+  try {
+    return await response.json();
+  } catch {
+    throw new ClipperApprovalError(
+      "CLIPPER_INVALID_RESPONSE",
+      "GNO returned malformed pairing data."
+    );
+  }
+};
+
+const requireSuccess = (response: Response, value: unknown): void => {
+  if (response.ok) return;
+  const parsed = parseError(value);
+  if (parsed) throw parsed;
+  throw new ClipperApprovalError(
+    "CLIPPER_INVALID_RESPONSE",
+    "GNO returned an unknown pairing error."
+  );
+};
+
+export async function approveClipperPair(
+  pairId: string,
+  pairingCode: string,
+  fetcher: typeof fetch = fetch
+): Promise<ClipperApproval> {
+  if (!PAIR_ID.test(pairId) || !PAIRING_CODE.test(pairingCode)) {
+    throw new ClipperApprovalError(
+      "CLIPPER_INVALID_REQUEST",
+      "Enter the exact eight-digit code shown by the extension."
+    );
+  }
+
+  const csrfResponse = await fetcher("/api/clipper/pair/csrf", {
+    method: "GET",
+    cache: "no-store",
+    credentials: "same-origin",
+  });
+  const csrfBody = await readJson(csrfResponse);
+  requireSuccess(csrfResponse, csrfBody);
+  if (
+    !isRecord(csrfBody) ||
+    !hasExactKeys(csrfBody, ["schemaVersion", "csrfToken"]) ||
+    csrfBody.schemaVersion !== "1.0" ||
+    typeof csrfBody.csrfToken !== "string" ||
+    !TOKEN.test(csrfBody.csrfToken)
+  ) {
+    throw new ClipperApprovalError(
+      "CLIPPER_INVALID_RESPONSE",
+      "GNO returned an unsupported pairing response."
+    );
+  }
+
+  const approvalResponse = await fetcher("/api/clipper/pair/approve", {
+    method: "POST",
+    cache: "no-store",
+    credentials: "same-origin",
+    headers: {
+      "Content-Type": "application/json",
+      "X-GNO-CSRF": csrfBody.csrfToken,
+    },
+    body: JSON.stringify({ pairId, pairingCode }),
+  });
+  const approvalBody = await readJson(approvalResponse);
+  requireSuccess(approvalResponse, approvalBody);
+  if (
+    !isRecord(approvalBody) ||
+    !hasExactKeys(approvalBody, [
+      "schemaVersion",
+      "status",
+      "origin",
+      "expiresAt",
+    ]) ||
+    approvalBody.schemaVersion !== "1.0" ||
+    approvalBody.status !== "approved" ||
+    typeof approvalBody.origin !== "string" ||
+    !EXTENSION_ORIGIN.test(approvalBody.origin) ||
+    !isDateTime(approvalBody.expiresAt)
+  ) {
+    throw new ClipperApprovalError(
+      "CLIPPER_INVALID_RESPONSE",
+      "GNO returned an unsupported pairing response."
+    );
+  }
+  return {
+    origin: approvalBody.origin,
+    expiresAt: approvalBody.expiresAt,
+  };
+}

package/src/serve/public/pages/ClipperPairing.tsx

@@ -0,0 +1,210 @@
+import {
+  AlertCircleIcon,
+  CheckCircle2Icon,
+  LinkIcon,
+  Loader2Icon,
+} from "lucide-react";
+import { useState } from "react";
+
+import { GnoLogo } from "../components/GnoLogo";
+import { Button } from "../components/ui/button";
+import {
+  Card,
+  CardContent,
+  CardDescription,
+  CardFooter,
+  CardHeader,
+  CardTitle,
+} from "../components/ui/card";
+import { Input } from "../components/ui/input";
+import {
+  approveClipperPair,
+  ClipperApprovalError,
+  type ClipperApproval,
+} from "../lib/clipper-approval";
+
+interface ClipperPairingProps {
+  pairId: string | null;
+}
+
+type PairingState = "ready" | "approving" | "approved" | "terminal";
+
+const terminalCodes = new Set([
+  "CLIPPER_PAIR_EXPIRED",
+  "CLIPPER_PAIR_ALREADY_USED",
+  "CLIPPER_PAIR_NOT_FOUND",
+]);
+
+export default function ClipperPairing({ pairId }: ClipperPairingProps) {
+  const [activePairId, setActivePairId] = useState(pairId);
+  const [pairingCode, setPairingCode] = useState("");
+  const [state, setState] = useState<PairingState>(
+    pairId === null ? "terminal" : "ready"
+  );
+  const [approval, setApproval] = useState<ClipperApproval | null>(null);
+  const [error, setError] = useState<string | null>(
+    pairId === null
+      ? "This pairing link is invalid. Start pairing again from the extension."
+      : null
+  );
+
+  const clearSensitiveState = () => {
+    setPairingCode("");
+    setActivePairId(null);
+  };
+
+  const approve = async () => {
+    if (activePairId === null || !/^\d{8}$/u.test(pairingCode)) return;
+    setState("approving");
+    setError(null);
+    try {
+      const result = await approveClipperPair(activePairId, pairingCode);
+      clearSensitiveState();
+      setApproval(result);
+      setState("approved");
+    } catch (cause) {
+      const parsed =
+        cause instanceof ClipperApprovalError
+          ? cause
+          : new ClipperApprovalError(
+              "CLIPPER_NETWORK",
+              "Could not reach the local GNO gateway. Keep the extension open and retry.",
+              true
+            );
+      setError(parsed.message);
+      if (terminalCodes.has(parsed.code) || !parsed.retryable) {
+        clearSensitiveState();
+        setState("terminal");
+      } else {
+        setPairingCode("");
+        setState("ready");
+      }
+    }
+  };
+
+  const cancel = () => {
+    clearSensitiveState();
+    setError("Pairing cancelled. Start again from the extension when ready.");
+    setState("terminal");
+  };
+
+  return (
+    <main className="relative flex min-h-screen items-center justify-center overflow-hidden bg-background p-6">
+      <div className="pointer-events-none absolute inset-0 bg-[radial-gradient(circle_at_top_left,oklch(0.68_0.11_55/0.12),transparent_42%),radial-gradient(circle_at_bottom_right,oklch(0.52_0.08_245/0.10),transparent_48%)]" />
+      <Card className="relative w-full max-w-lg border-border/70 shadow-2xl">
+        <CardHeader>
+          <div className="mb-3 flex items-center gap-3 text-primary">
+            <GnoLogo className="size-9" />
+            <span className="font-mono text-xs tracking-[0.2em] uppercase">
+              Local approval
+            </span>
+          </div>
+          <CardTitle className="font-semibold text-2xl">
+            Pair the GNO browser clipper
+          </CardTitle>
+          <CardDescription className="leading-6">
+            This extension may send only content you explicitly capture into
+            this local GNO. Access expires within 30 days and can be revoked
+            from the extension.
+          </CardDescription>
+        </CardHeader>
+        <CardContent className="space-y-5">
+          {state === "ready" || state === "approving" ? (
+            <>
+              <div className="rounded-lg border border-border/60 bg-muted/25 p-4 text-sm">
+                <div className="mb-2 flex items-center gap-2 font-medium">
+                  <LinkIcon className="size-4 text-primary" />
+                  Confirm this browser
+                </div>
+                <p className="text-muted-foreground">
+                  Enter the eight-digit code shown in the extension. GNO never
+                  gives this page the extension grant.
+                </p>
+              </div>
+              <label className="block space-y-2">
+                <span className="font-medium text-sm">Pairing code</span>
+                <Input
+                  aria-label="Pairing code"
+                  autoComplete="off"
+                  autoFocus
+                  className="h-12 font-mono text-lg tracking-[0.3em]"
+                  disabled={state === "approving"}
+                  inputMode="numeric"
+                  maxLength={8}
+                  onChange={(event) =>
+                    setPairingCode(
+                      event.currentTarget.value
+                        .replaceAll(/\D/gu, "")
+                        .slice(0, 8)
+                    )
+                  }
+                  pattern="[0-9]{8}"
+                  placeholder="00000000"
+                  value={pairingCode}
+                />
+              </label>
+            </>
+          ) : null}
+
+          {approval ? (
+            <div
+              className="rounded-lg border border-emerald-500/30 bg-emerald-500/10 p-4"
+              role="status"
+            >
+              <div className="mb-2 flex items-center gap-2 font-medium text-emerald-700 dark:text-emerald-300">
+                <CheckCircle2Icon className="size-5" />
+                Browser paired
+              </div>
+              <p className="break-all text-muted-foreground text-sm">
+                {approval.origin}
+              </p>
+              <p className="mt-1 text-muted-foreground text-xs">
+                Expires {new Date(approval.expiresAt).toLocaleString()}
+              </p>
+            </div>
+          ) : null}
+
+          {error ? (
+            <div
+              className="flex gap-3 rounded-lg border border-destructive/30 bg-destructive/10 p-4 text-sm"
+              role="alert"
+            >
+              <AlertCircleIcon className="mt-0.5 size-4 shrink-0 text-destructive" />
+              <span>{error}</span>
+            </div>
+          ) : null}
+        </CardContent>
+        <CardFooter className="justify-between gap-3">
+          {state === "ready" || state === "approving" ? (
+            <>
+              <Button
+                disabled={state === "approving"}
+                onClick={cancel}
+                type="button"
+                variant="ghost"
+              >
+                Cancel
+              </Button>
+              <Button
+                disabled={
+                  state === "approving" || !/^\d{8}$/u.test(pairingCode)
+                }
+                onClick={() => void approve()}
+                type="button"
+              >
+                {state === "approving" ? (
+                  <Loader2Icon className="animate-spin" />
+                ) : null}
+                Approve extension
+              </Button>
+            </>
+          ) : (
+            <Button asChild className="ml-auto" variant="outline">
+              <a href="/">Back to GNO</a>
+            </Button>
+          )}
+        </CardFooter>
+      </Card>
+    </main>
+  );
+}

package/src/serve/routes/api.ts

@@ -6,9 +6,9 @@
  */
 
 // node:fs/promises structure ops have no Bun equivalent
-import { mkdir, readdir } from "node:fs/promises";
+import { readdir } from "node:fs/promises";
 // node:path has no Bun equivalent
-import { dirname, join as pathJoin, posix as pathPosix } from "node:path";
+import { posix as pathPosix } from "node:path";
 
 import type {
   Collection,
@@ -48,14 +48,7 @@ import {
   fingerprintContentTypeRules,
   normalizeContentTypes,
 } from "../../config";
-import {
-  buildCaptureReceipt,
-  listCaptureDiskRelPaths,
-  planCapture,
-  type CapturePlan,
-  type PublicCaptureInput,
-} from "../../core/capture";
-import { writeCapturePlanFile } from "../../core/capture-write";
+import { type PublicCaptureInput } from "../../core/capture";
 import {
   type ConnectorVerificationCode,
   getConnectorVerificationRemediation,
@@ -146,6 +139,10 @@ import {
 } from "../../publish/artifact";
 import { exportPublishArtifact } from "../../publish/export-service";
 import { buildBrowseTree, normalizeBrowsePath } from "../browse-tree";
+import {
+  executeResidentCapturePlan,
+  planResidentCapture,
+} from "../capture-service";
 import { applyConfigChange, applyConfigChangeTyped } from "../config-sync";
 import {
   getConnectorStatuses,
@@ -3167,114 +3164,21 @@ export async function handleCreateCapture(
     );
   }
 
-  const collectionName = body.collection.toLowerCase();
-  const collection = ctxHolder.config.collections.find(
-    (candidate) => candidate.name.toLowerCase() === collectionName
-  );
-  if (!collection) {
-    return errorResponse(
-      "NOT_FOUND",
-      `Collection not found: ${body.collection}`,
-      404
-    );
-  }
-
-  let plan: CapturePlan;
-  try {
-    plan = planCapture({
-      input: {
-        ...body,
-        collection: collection.name,
-      },
-      existingRelPaths: await listCollectionRelPaths(store, collection.name),
-      diskRelPaths: await listCaptureDiskRelPaths(collection.path),
-    });
-  } catch (error) {
-    return errorResponse(
-      "VALIDATION",
-      error instanceof Error ? error.message : String(error),
-      409
-    );
-  }
-
-  const fullPath = pathJoin(collection.path, plan.relPath);
-  if (plan.openedExisting) {
-    const existingDoc = await store.getDocument(collection.name, plan.relPath);
-    if (!existingDoc.ok) {
-      return errorResponse("RUNTIME", existingDoc.error.message, 500);
-    }
-    return jsonResponse(
-      buildCaptureReceipt({
-        plan,
-        absPath: fullPath,
-        docid: existingDoc.value?.docid,
-        sync: existingDoc.value
-          ? { status: "completed" }
-          : {
-              status: "skipped",
-              reason: "Existing file is not indexed yet.",
-            },
-      })
-    );
+  const planned = await planResidentCapture(ctxHolder, store, {
+    ...body,
+    collection: body.collection,
+  });
+  if (!planned.ok) {
+    return errorResponse(planned.code, planned.message, planned.status);
   }
-
   try {
-    await mkdir(dirname(fullPath), { recursive: true });
-    ctxHolder.watchService?.suppress(fullPath);
-    await writeCapturePlanFile(plan, fullPath);
-
-    const gnoUri = `gno://${collection.name}/${plan.relPath}`;
-    const jobResult = await startJob(
-      "sync",
-      async (): Promise<SyncResult> => {
-        const result = await syncResidentCollection(
-          ctxHolder,
-          collection,
-          store,
-          withContentTypeRules({ runUpdateCmd: false }, ctxHolder.config),
-          deps?.syncCollection
-        );
-        ctxHolder.scheduler?.notifySyncComplete([plan.relPath]);
-        ctxHolder.eventBus?.emit({
-          type: "document-changed",
-          uri: gnoUri,
-          collection: collection.name,
-          relPath: plan.relPath,
-          origin: "create",
-          changedAt: new Date().toISOString(),
-        });
-        return {
-          collections: [result],
-          totalDurationMs: result.durationMs,
-          totalFilesProcessed: result.filesProcessed,
-          totalFilesAdded: result.filesAdded,
-          totalFilesUpdated: result.filesUpdated,
-          totalFilesErrored: result.filesErrored,
-          totalFilesSkipped: result.filesSkipped,
-        };
-      },
-      ctxHolder.jobManager
-    );
-
-    return jsonResponse(
-      buildCaptureReceipt({
-        plan,
-        absPath: fullPath,
-        sync: jobResult.ok
-          ? {
-              status: "pending",
-              jobId: jobResult.jobId,
-              reason: "Sync job started; poll /api/jobs/:id for status.",
-            }
-          : {
-              status: "skipped",
-              jobId: jobResult.activeJobId,
-              reason: "Sync skipped because another job is running.",
-              error: jobResult.error,
-            },
-      }),
-      202
+    const result = await executeResidentCapturePlan(
+      ctxHolder,
+      store,
+      planned,
+      deps
     );
+    return jsonResponse(result.body, result.status);
   } catch (error) {
     return errorResponse(
       "RUNTIME",