@xpufx/paseo-twofado 0.1.0 → 0.1.1

package/client/vendor/paseo-plugin-helper/utils/clipboard.ts

@@ -24,16 +24,23 @@ export interface ClipboardEnvironment {
  * `react-native-web` `Clipboard.setString` reports success even when its
  * `document.execCommand("copy")` fails, which leaves the previous clipboard
  * item in place while the UI claims success (xpufx-org/paseo#278); it is only
- * usable off-DOM (native), where it is the real platform clipboard. In a DOM
- * the checked `execCommand` fallback is preferred to that unverifiable path.
+ * usable off-DOM (native), where it is the real platform clipboard. The same
+ * applies to any `setStringAsync` whose DOM fallback is that unverified
+ * `execCommand`. In a DOM the checked `execCommand` fallback is preferred to
+ * those unverifiable paths.
  */
 export function clipboardTierOrder(env: ClipboardEnvironment): ClipboardTier[] {
   const tiers: ClipboardTier[] = [];
   if (env.hasNavigatorClipboard) tiers.push("navigator");
   if (env.hasHostCopyText) tiers.push("host");
-  if (env.hasRnSetStringAsync) {
+  // On a DOM both RN-web paths are unverifiable: `setString` reports success
+  // even when its `execCommand` no-ops, and a `setStringAsync` that falls back
+  // to it does the same. Off-DOM they are the real native clipboard, so they
+  // lead there; on a DOM only the checked `execCommand` fallback is honest.
+  const rnDomOk = !env.isDom;
+  if (env.hasRnSetStringAsync && rnDomOk) {
     tiers.push("rnAsync");
-  } else if (env.hasRnClipboard && !env.isDom) {
+  } else if (env.hasRnClipboard && rnDomOk) {
     tiers.push("rnSync");
   }
   tiers.push("execCommand");

package/index.client.tsx

@@ -0,0 +1,91 @@
+import type { PluginClientContext, PluginSurfaceProps } from "@getpaseo/plugin/client";
+import { useRpc } from "@getpaseo/plugin/client";
+import { Icon, Modal, ScrollView, useToast } from "@getpaseo/plugin/client/react-native";
+import {
+  initClientHelpers,
+  registerSidebarSurface,
+} from "paseo-plugin-helper/client";
+import { ErrorBoundary } from "./client/error-boundary";
+import {
+  ApprovalHeaderIcon,
+  ApprovalSurface,
+  trackHeaderButton,
+  untrackHeaderButton,
+} from "./client/approvals";
+
+export default function contribute(client: PluginClientContext) {
+  initClientHelpers({ Icon, Modal, useRpc, useToast, ScrollView });
+
+  const Surface = (props: PluginSurfaceProps) => (
+    <ErrorBoundary label="approvals surface" fallback={null}>
+      <ApprovalSurface {...props} />
+    </ErrorBoundary>
+  );
+  // Helper primitive instead of a handrolled surface registration: besides
+  // injecting the theme provider it marks the subtree as helper-scroll-owned,
+  // so the page owns a working scroll region on a wide desktop window
+  // (xpufx-org/paseo#213) rather than clipping.
+  registerSidebarSurface(client, {
+    id: "approvals",
+    title: "2fado",
+    icon: "ShieldCheck",
+    Component: Surface,
+  });
+  client.addCommandCenterItem({
+    id: "open-approvals",
+    title: "Open 2fado",
+    icon: "ShieldCheck",
+    context: "global",
+    onSelect({ openSurface }) {
+      openSurface("approvals");
+    },
+  });
+
+  const buttons = new Map<string, () => void>();
+  const addButton = (workspaceId: string) => {
+    if (!workspaceId || buttons.has(workspaceId)) return;
+    const registration = client.addHeaderButton({
+      id: "twofado",
+      workspaceId,
+      button: {
+        title: "2fado",
+        icon: ApprovalHeaderIcon,
+        behavior: { kind: "action", onPress: () => client.openSurface("approvals") },
+      },
+    });
+    buttons.set(workspaceId, () => {
+      untrackHeaderButton(workspaceId);
+      registration.remove();
+    });
+    trackHeaderButton(workspaceId, registration);
+  };
+  const unsubscribe = client.paseo.agents.subscribe((update) => {
+    if (update.kind !== "upsert" || !update.agent.workspaceId) return;
+    addButton(update.agent.workspaceId);
+  });
+  // Register buttons for agents already present: subscribe only fires on
+  // future upserts, so without this the icon is missing after a Paseo
+  // restart until the next agent event — including when the daemon is down
+  // and the red down-state should be showing.
+  void Promise.resolve()
+    .then(() => client.paseo.agents.list())
+    .then(
+      (res) => {
+        const entries = Array.isArray(
+          (res as unknown as { entries?: unknown }).entries,
+        )
+          ? (res as unknown as { entries: Array<{ agent?: { workspaceId?: unknown } }> }).entries
+          : [];
+        for (const { agent } of entries) {
+          if (typeof agent?.workspaceId === "string") addButton(agent.workspaceId);
+        }
+      },
+      (err) => console.warn("[2fado] Failed to list agents for header buttons:", err),
+    );
+
+  return () => {
+    unsubscribe();
+    for (const remove of buttons.values()) remove();
+    buttons.clear();
+  };
+}

package/index.server.ts

@@ -0,0 +1,97 @@
+import fs from "node:fs";
+import type { PluginServerContext } from "@getpaseo/plugin/server";
+import { PluginStorage, createPluginLogger, registerSettingsRpc } from "paseo-plugin-helper/server";
+import {
+  approvalAck,
+  approvalSettings,
+  approvalStatus,
+  approvalTelegramInfo,
+  approvalTelegramSetConfig,
+  daemonHealth,
+  migrateLegacyNotificationTarget,
+  pendingList,
+  policyAddRule,
+  recentList,
+  verdict,
+} from "./shared/approval";
+import type { ApprovalSettingsValues } from "./shared/approval";
+import {
+  addPolicyRule,
+  getHealth,
+  getStatus,
+  getTelegramInfo,
+  listPending,
+  listRecent,
+  setTelegramConfig,
+  submitAck,
+  submitVerdict,
+} from "./server/twofado";
+
+const log = createPluginLogger("twofado");
+
+function migrateLegacySettingsFile(storage: PluginStorage<ApprovalSettingsValues>): void {
+  try {
+    const raw = fs.readFileSync(storage.filePath, "utf8");
+    const { data, changed } = migrateLegacyNotificationTarget(JSON.parse(raw));
+    if (!changed) return;
+    fs.writeFileSync(storage.filePath, JSON.stringify(data, null, 2));
+    log.info("migrated legacy telegramFallback to notificationTarget");
+  } catch (err) {
+    // Missing or unreadable file: schema defaults apply.
+    log.warn("legacy settings migration skipped", { error: err });
+  }
+}
+
+export default function contribute(server: PluginServerContext) {
+  const storage = new PluginStorage("twofado", "settings.json", {
+    defaultData: approvalSettings.defaultSettings,
+    schema: approvalSettings.schema,
+  });
+  migrateLegacySettingsFile(storage);
+  registerSettingsRpc(server, approvalSettings, storage, {
+    onUpdate: (next, prev) => {
+      log.info("settings updated", {
+        socketPath: next.socketPath,
+        notificationTarget: next.notificationTarget,
+      });
+      if (next.telegramBotToken || next.telegramChatId || next.telegramApprovers) {
+        const approvers = next.telegramApprovers
+          ? next.telegramApprovers
+              .split(/[\s,]+/)
+              .map((s) => s.trim())
+              .filter(Boolean)
+          : [];
+        void setTelegramConfig({
+          botToken: next.telegramBotToken || undefined,
+          chatId: next.telegramChatId || undefined,
+          approvers,
+          notificationTarget: next.notificationTarget,
+          socketPath: next.socketPath,
+        }).catch((err) => log.warn("failed to sync telegram config to daemon", { error: err }));
+      } else if (prev && next.notificationTarget !== prev.notificationTarget) {
+        void (async () => {
+          const info = await getTelegramInfo({ socketPath: next.socketPath }).catch((err) => {
+            log.warn("telegram info fetch failed during target sync", { error: err });
+            return undefined;
+          });
+          await setTelegramConfig({
+            chatId: info?.chatId,
+            approvers: info?.approvers,
+            notificationTarget: next.notificationTarget,
+            socketPath: next.socketPath,
+          });
+        })().catch((err) => log.warn("failed to sync notification target to daemon", { error: err }));
+      }
+    },
+  });
+  server.handle(pendingList, (input) => listPending(input));
+  server.handle(verdict, (input) => submitVerdict(input));
+  server.handle(approvalAck, (input) => submitAck(input));
+  server.handle(recentList, (input) => listRecent(input));
+  server.handle(approvalStatus, (input) => getStatus(input));
+  server.handle(daemonHealth, (input) => getHealth(input));
+  server.handle(approvalTelegramInfo, (input) => getTelegramInfo(input));
+  server.handle(approvalTelegramSetConfig, (input) => setTelegramConfig(input));
+  server.handle(policyAddRule, (input) => addPolicyRule(input));
+  return () => {};
+}

package/package.json

@@ -2,7 +2,7 @@
   "name": "@xpufx/paseo-twofado",
   "private": false,
   "license": "MIT",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "type": "module",
   "scripts": {
     "typecheck": "tsc --noEmit"
@@ -21,6 +21,8 @@
     "paseo-plugin.json",
     "README.md",
     "LICENSE",
+    "index.client.tsx",
+    "index.server.ts",
     "client",
     "server",
     "shared",