@abraca/cli 1.9.1 → 2.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@abraca/cli",
-  "version": "1.9.1",
+  "version": "2.3.0",
   "description": "CLI for Abracadabra — interact with CRDT document workspaces from the terminal",
   "license": "MIT",
   "type": "module",
@@ -28,12 +28,17 @@
     "dist"
   ],
   "dependencies": {
-    "@noble/ed25519": "^2.3.0",
-    "@noble/hashes": "^1.8.0"
+    "@noble/ed25519": "^3.1.0",
+    "@noble/hashes": "^2.2.0",
+    "wtf-plugin-api": "^2.0.1",
+    "wtf_wikipedia": "^10.4.1"
   },
   "peerDependencies": {
-    "@abraca/dabra": ">=1.0.0",
+    "@abraca/dabra": ">=2.0.0",
     "y-protocols": "^1.0.6",
     "yjs": "^13.6.8"
+  },
+  "devDependencies": {
+    "@abraca/dabra": "2.3.0"
   }
-}
+}

package/src/commands/awareness.ts

@@ -96,27 +96,30 @@ registerCommand({
 registerCommand({
   name: 'chat',
   aliases: ['send'],
-  description: 'Send a chat message to a channel.',
-  usage: 'chat channel=<group:docId> text=<message>',
+  description: 'Send a chat message to a channel doc.',
+  usage: 'chat channel_doc_id=<docId> text=<message>',
   async run(conn: CLIConnection | null, args: ParsedArgs): Promise<string> {
     if (!conn) return 'Not connected'
 
     const rootProvider = conn.rootProvider
     if (!rootProvider) return 'Not connected'
 
-    const channel = args.params['channel']
-    if (!channel) return 'Missing required parameter: channel=<group:docId>'
+    // Accept either `channel_doc_id` or legacy `channel` (with optional
+    // `group:` prefix the new server doesn't use — strip it).
+    const raw = args.params['channel_doc_id'] || args.params['channel']
+    if (!raw) return 'Missing required parameter: channel_doc_id=<docId>'
+    const channel_doc_id = raw.startsWith('group:') ? raw.slice(6) : raw
 
     const text = args.params['text'] || args.params['content'] || args.positional[0]
     if (!text) return 'Missing required parameter: text=<message>'
 
     rootProvider.sendStateless(JSON.stringify({
-      type: 'chat:send',
-      channel,
+      type: 'messages:send',
+      channel_doc_id,
       content: text,
-      sender_name: conn.displayName,
+      mentions: [],
     }))
 
-    return `Sent to ${channel}`
+    return `Sent to ${channel_doc_id}`
   },
 })

package/src/commands/spaces.ts

@@ -4,8 +4,8 @@
 import { registerCommand } from '../command.ts'
 import type { CLIConnection } from '../connection.ts'
 import type { ParsedArgs } from '../parser.ts'
-import { printJson, printTable, getFormat, pad } from '../output.ts'
-import { readEntries, childrenOf } from '../resolve.ts'
+import { printJson, printTable, getFormat } from '../output.ts'
+import { readEntries } from '../resolve.ts'
 
 registerCommand({
   name: 'info',
@@ -28,7 +28,7 @@ registerCommand({
       `URL:         ${conn.config.url}`,
       `Version:     ${si.version ?? '—'}`,
       `Protocol:    ${si.protocol_version ?? '—'}`,
-      `Hub Doc:     ${conn.rootDocId ?? '—'}`,
+      `Active Doc:  ${conn.rootDocId ?? '—'}`,
       `Auth:        ${si.auth_methods?.join(', ') ?? '—'}`,
       `Registration:${si.registration_allowed ? ' open' : ' closed'}${si.invite_only ? ' (invite only)' : ''}`,
       `Documents:   ${docCount}`,
@@ -40,7 +40,7 @@ registerCommand({
 
 registerCommand({
   name: 'spaces',
-  description: 'List available spaces/root documents.',
+  description: 'List available spaces (top-level documents).',
   usage: 'spaces [--format=json|tsv]',
   async run(conn: CLIConnection | null, args: ParsedArgs): Promise<string> {
     if (!conn) return 'Not connected'
@@ -51,18 +51,20 @@ registerCommand({
     const active = conn.rootDocId
 
     if (format === 'json') {
-      return printJson(spaces.map(s => ({ ...s, active: s.doc_id === active })))
+      return printJson(spaces.map(s => ({ ...s, active: s.id === active })))
     }
 
-    const rows = spaces.map(s => [
-      s.doc_id === active ? '▸' : ' ',
-      s.doc_id.slice(0, 8) + '…',
-      s.name,
-      s.is_hub ? 'hub' : '',
-      s.visibility,
-    ])
+    const rows = spaces.map(s => {
+      const visibility = s.public_access === 'observer' ? 'public' : 'private'
+      return [
+        s.id === active ? '▸' : ' ',
+        s.id.slice(0, 8) + '…',
+        s.label ?? s.id,
+        visibility,
+      ]
+    })
 
-    return printTable(rows, ['', 'ID', 'NAME', 'HUB', 'VISIBILITY'])
+    return printTable(rows, ['', 'ID', 'NAME', 'VISIBILITY'])
   },
 })
 
@@ -84,9 +86,9 @@ registerCommand({
     } else if (targetName) {
       const lower = targetName.toLowerCase()
       const space = conn.spaces.find(s =>
-        s.name.toLowerCase() === lower || s.doc_id === targetName
+        (s.label ?? s.id).toLowerCase() === lower || s.id === targetName
       )
-      if (space) docId = space.doc_id
+      if (space) docId = space.id
     }
 
     if (!docId) {
@@ -94,7 +96,7 @@ registerCommand({
     }
 
     await conn.switchSpace(docId)
-    const space = conn.spaces.find(s => s.doc_id === docId)
-    return `Switched to space "${space?.name ?? docId}"`
+    const space = conn.spaces.find(s => s.id === docId)
+    return `Switched to space "${space?.label ?? docId}"`
   },
 })

package/src/commands/tree.ts

@@ -51,9 +51,9 @@ registerCommand({
       return '(empty tree)'
     }
 
-    // Find root label for header
-    const hubSpace = conn.spaces.find(s => s.doc_id === conn.rootDocId)
-    const rootLabel = hubSpace?.name ?? conn.rootDocId ?? 'Workspace'
+    // Find root label for header — the active Space, falling back to its id.
+    const activeSpace = conn.spaces.find(s => s.id === conn.rootDocId)
+    const rootLabel = activeSpace?.label ?? conn.rootDocId ?? 'Workspace'
 
     return rootLabel + '\n' + printTree(toTreeNodes(tree))
   },

package/src/commands/wiki/connect.ts

@@ -0,0 +1,69 @@
+/**
+ * Open a DocumentManager session for the wiki command, mirroring the
+ * auth/register flow that CLIConnection uses but using the modern public API.
+ *
+ * Reuses the CLI's Ed25519 keypair handling (loadOrCreateKeypair, signChallenge)
+ * so the wiki command authenticates with the same identity as every other
+ * subcommand.
+ */
+import { DocumentManager } from '@abraca/dabra'
+import { loadOrCreateKeypair, signChallenge } from '../../crypto.ts'
+
+export interface OpenSessionConfig {
+  url: string
+  name?: string
+  color?: string
+  inviteCode?: string
+  keyFile?: string
+  /** Suppress informational stderr logging. */
+  quiet?: boolean
+}
+
+export interface OpenSessionResult {
+  dm: DocumentManager
+  /** Active root doc id (the entry-point space). */
+  rootDocId: string
+}
+
+export async function openSession(config: OpenSessionConfig): Promise<OpenSessionResult> {
+  const keypair = await loadOrCreateKeypair(config.keyFile)
+  const sign = (challenge: string) => Promise.resolve(signChallenge(challenge, keypair.privateKey))
+
+  const dm = new DocumentManager({
+    url: config.url,
+    name: config.name ?? 'Wiki Extractor',
+    color: config.color,
+    quiet: config.quiet,
+  })
+
+  // Authenticate first; register on first run.
+  try {
+    await dm.client.loginWithKey(keypair.publicKeyB64, sign)
+  } catch (err: any) {
+    const status = err?.status ?? err?.response?.status
+    if (status === 404 || status === 422) {
+      if (!config.quiet) {
+        console.error('[abracadabra] Key not registered, creating new account...')
+      }
+      await dm.client.registerWithKey({
+        publicKey: keypair.publicKeyB64,
+        username: (config.name ?? 'wiki-extractor').replace(/\s+/g, '-').toLowerCase(),
+        displayName: config.name ?? 'Wiki Extractor',
+        deviceName: 'CLI Wiki',
+        inviteCode: config.inviteCode,
+      })
+      await dm.client.loginWithKey(keypair.publicKeyB64, sign)
+    } else {
+      throw err
+    }
+  }
+
+  await dm.connect()
+
+  const rootDocId = dm.rootDocId
+  if (!rootDocId) {
+    throw new Error('Connected but no rootDocId — server has no spaces.')
+  }
+
+  return { dm, rootDocId }
+}