@abraca/orchestrator 2.34.0 → 2.35.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@abraca/orchestrator",
-  "version": "2.34.0",
+  "version": "2.35.1",
   "description": "CouShell commercial director — orchestrate simulated actors on Abracadabra for screen recording",
   "license": "MIT",
   "type": "module",
@@ -28,8 +28,7 @@
     "dist"
   ],
   "dependencies": {
-    "@noble/ed25519": "^3.1.0",
-    "@noble/hashes": "^2.2.0"
+    "@abraca/convert": "2.35.1"
   },
   "peerDependencies": {
     "@abraca/dabra": ">=1.0.0",

package/src/actions/content.ts

@@ -6,7 +6,7 @@
  */
 import type { ActorConnection } from '../actor-connection.ts'
 import type { WriteContentAction, DeleteContentAction } from '../types.ts'
-import { populateYDocFromMarkdown } from '../converters/markdownToYjs.ts'
+import { populateYDocFromMarkdown } from '@abraca/convert'
 import { bodyStartIndex } from '../yjs-utils.ts'
 
 export async function executeWriteContent(

package/src/actor-connection.ts

@@ -3,9 +3,16 @@
  * One instance per actor. Handles auth, providers, child caching, awareness, and cursors.
  */
 import * as Y from 'yjs'
-import { AbracadabraProvider, AbracadabraClient } from '@abraca/dabra'
+import {
+  AbracadabraProvider,
+  AbracadabraClient,
+  loadOrCreateKeyFile,
+  deterministicKeypair,
+  loginOrRegisterWithKey,
+  openSyncedProvider,
+  pickEntrySpace,
+} from '@abraca/dabra'
 import type { ActorDef, ServerConfig } from './types.ts'
-import { loadOrCreateKeypair, deterministicKeypair, signChallenge } from './crypto.ts'
 import { waitForSync, sleep, log } from './utils.ts'
 import { findTextPosition, fragmentTextLength } from './yjs-utils.ts'
 
@@ -44,38 +51,23 @@ export class ActorConnection {
   async connect(serverConfig: ServerConfig): Promise<void> {
     // Step 1: Get keypair (from file or deterministic from name)
     const keypair = this.actor.keyFile
-      ? await loadOrCreateKeypair(this.actor.keyFile)
+      ? await loadOrCreateKeyFile(this.actor.keyFile)
       : deterministicKeypair(this.actor.name)
     this._publicKey = keypair.publicKeyB64
-    const signFn = (challenge: string) =>
-      Promise.resolve(signChallenge(challenge, keypair.privateKey))
 
     // Step 2: Auth (auto-register on first run)
-    try {
-      await this.client.loginWithKey(keypair.publicKeyB64, signFn)
-    } catch (err: any) {
-      const status = err?.status ?? err?.response?.status
-      if (status === 404 || status === 422) {
-        log(`${this.actor.name}: registering new account...`)
-        await this.client.registerWithKey({
-          publicKey: keypair.publicKeyB64,
-          username: this.actor.name.replace(/\s+/g, '-').toLowerCase(),
-          displayName: this.actor.name,
-          deviceName: 'Orchestrator Actor',
-          inviteCode: serverConfig.inviteCode,
-        })
-        await this.client.loginWithKey(keypair.publicKeyB64, signFn)
-      } else {
-        throw err
-      }
-    }
+    await loginOrRegisterWithKey(this.client, keypair, {
+      displayName: this.actor.name,
+      deviceName: 'Orchestrator Actor',
+      inviteCode: serverConfig.inviteCode,
+      onRegister: () => log(`${this.actor.name}: registering new account...`),
+    })
     log(`${this.actor.name}: authenticated (${keypair.publicKeyB64.slice(0, 12)}...)`)
 
     // Step 3: Pick an entry-point doc — first Space under the server root,
     // falling back to the first top-level doc of any kind.
-    const roots = await this.client.listChildren()
-    const firstSpace = roots.find((d) => d.kind === 'space')
-    const rootDocId = (firstSpace ?? roots[0])?.id ?? null
+    const { entry } = pickEntrySpace(await this.client.listChildren())
+    const rootDocId = entry?.id ?? null
 
     if (!rootDocId) {
       throw new Error(`${this.actor.name}: no root document found`)
@@ -83,15 +75,7 @@ export class ActorConnection {
     this._rootDocId = rootDocId
 
     // Step 4: Connect provider
-    const doc = new Y.Doc({ guid: rootDocId })
-    const provider = new AbracadabraProvider({
-      name: rootDocId,
-      document: doc,
-      client: this.client,
-      disableOfflineStore: true,
-      subdocLoading: 'lazy',
-    })
-    await waitForSync(provider)
+    const { doc, provider } = await openSyncedProvider({ client: this.client, docId: rootDocId })
 
     this._rootDoc = doc
     this._rootProvider = provider

package/src/utils.ts

@@ -1,49 +1,17 @@
 /**
  * Utility functions for the orchestrator.
+ *
+ * `waitForSync` / `withTimeout` are the shared provider implementations from
+ * `@abraca/dabra` (`DocUtils`), re-exported here so existing `./utils.ts`
+ * importers keep working. `sleep` / `log` are orchestrator-local.
  */
-
-/** Wait for a provider's `synced` event with a timeout. Resolves immediately if already synced. */
-export function waitForSync(
-  provider: { on(event: string, cb: () => void): void; off(event: string, cb: () => void): void; synced?: boolean },
-  timeoutMs = 15000
-): Promise<void> {
-  // If already synced, resolve immediately
-  if (provider.synced) return Promise.resolve()
-
-  return new Promise<void>((resolve, reject) => {
-    const timer = setTimeout(() => {
-      provider.off('synced', handler)
-      reject(new Error(`Sync timed out after ${timeoutMs}ms`))
-    }, timeoutMs)
-
-    function handler() {
-      clearTimeout(timer)
-      resolve()
-    }
-
-    provider.on('synced', handler)
-  })
-}
+export { waitForSync, withTimeout } from '@abraca/dabra'
 
 /** Sleep for a given number of milliseconds. */
 export function sleep(ms: number): Promise<void> {
   return new Promise(resolve => setTimeout(resolve, ms))
 }
 
-/** Wraps a promise with a timeout. */
-export function withTimeout<T>(promise: Promise<T>, timeoutMs: number, message?: string): Promise<T> {
-  return new Promise<T>((resolve, reject) => {
-    const timer = setTimeout(
-      () => reject(new Error(message ?? `Operation timed out after ${timeoutMs}ms`)),
-      timeoutMs
-    )
-    promise.then(
-      (val) => { clearTimeout(timer); resolve(val) },
-      (err) => { clearTimeout(timer); reject(err) }
-    )
-  })
-}
-
 /** Log to stderr with [orchestrator] prefix. */
 export function log(msg: string): void {
   console.error(`[orchestrator] ${msg}`)