synomem 0.9.5 → 0.10.0

package/src/actor-directory.ts

@@ -0,0 +1,87 @@
+import { SynomemError } from './errors.js';
+import { cursorFilter } from './cursors.js';
+import type { CursorBinding } from './cursors.js';
+import type { AddressableActor, ActorRef } from './policy.js';
+import type { ActorIdentity, ItemSummary, Page } from './types.js';
+export interface ActorProfileInput {
+  target: ActorRef;
+  after?: string;
+  limit?: number;
+}
+export interface ActorProfile {
+  actor: AddressableActor;
+  counts: { kudosReceived: number; usefulReceived: number };
+  authored: Page<ItemSummary>;
+}
+export interface ActorDirectoryInput {
+  query?: string;
+  kind?: 'human' | 'agent';
+  cursor?: string;
+  limit?: number;
+}
+export interface ActorDirectoryPage {
+  items: AddressableActor[];
+  hasMore: boolean;
+  nextCursor?: string;
+  total: number;
+  limit: number;
+}
+export function actorDirectoryBinding(
+  workspaceId: string,
+  viewer: ActorIdentity,
+  input: ActorDirectoryInput,
+): CursorBinding {
+  return {
+    purpose: 'actor-directory',
+    workspaceId,
+    actor: { kind: viewer.kind, id: viewer.id },
+    filter: cursorFilter({ query: (input.query ?? '').toLowerCase(), kind: input.kind ?? null }),
+  };
+}
+export function actorDirectoryKey(actor: Pick<AddressableActor, 'kind' | 'handle' | 'id'>): string {
+  return JSON.stringify([actor.kind, actor.handle, actor.id]);
+}
+export function parseActorDirectoryKey(key: string): [string, string, string] {
+  try {
+    const parts: unknown = JSON.parse(key);
+    if (
+      Array.isArray(parts) &&
+      parts.length === 3 &&
+      (parts[0] === 'human' || parts[0] === 'agent') &&
+      typeof parts[1] === 'string' &&
+      typeof parts[2] === 'string' &&
+      parts[1].length <= 100 &&
+      parts[2].length <= 200
+    )
+      return parts as [string, string, string];
+  } catch {
+    // A signed cursor can still be stale or malformed after a codec change.
+  }
+  throw new SynomemError('INVALID_INPUT', 'Invalid actor directory cursor.');
+}
+export function actorDirectoryInput(
+  input: ActorDirectoryInput = {},
+): Required<Pick<ActorDirectoryInput, 'query' | 'limit'>> &
+  Pick<ActorDirectoryInput, 'kind' | 'cursor'> {
+  if (
+    Object.keys(input).some((key) => !['query', 'kind', 'cursor', 'limit'].includes(key)) ||
+    (input.query !== undefined && typeof input.query !== 'string') ||
+    (input.kind !== undefined && !['human', 'agent'].includes(input.kind)) ||
+    (input.cursor !== undefined &&
+      (typeof input.cursor !== 'string' ||
+        input.cursor.length < 1 ||
+        input.cursor.length > 4096)) ||
+    (input.limit !== undefined &&
+      (!Number.isSafeInteger(input.limit) || input.limit < 1 || input.limit > 50))
+  )
+    throw new SynomemError('INVALID_INPUT', 'Invalid actor directory query.');
+  const query = (input.query ?? '').trim();
+  if (query.length > 100)
+    throw new SynomemError('INVALID_INPUT', 'Actor query is limited to 100 characters.');
+  return {
+    query,
+    limit: input.limit ?? 20,
+    ...(input.kind ? { kind: input.kind } : {}),
+    ...(input.cursor ? { cursor: input.cursor } : {}),
+  };
+}

package/src/backend.ts

@@ -1,3 +1,4 @@
+import { DatabaseSync } from 'node:sqlite';
 /**
  * Local store helpers.
  *
@@ -13,7 +14,7 @@
 import { chmodSync, existsSync, lstatSync, mkdirSync } from 'node:fs';
 import { join } from 'node:path';
 import { ulid } from 'ulid';
-import { SynomemClient } from './client.js';
+import { createLocalOwnerClient, SynomemClient } from './client.js';
 import { defaultConfig, mergeConfig, resolveHome } from './config.js';
 import { SynomemError } from './errors.js';
 import {
@@ -72,10 +73,10 @@ export function ensureLocalStore(explicitHome?: string): SynomemConfig {
   if (lstatSync(home).isSymbolicLink()) {
     throw new SynomemError('UNSAFE_PATH', 'The configured Synomem home cannot be a symbolic link.');
   }
-  ensureDirectory(home);
-  chmodSync(home, 0o700);
   const existing = readSynomemConfig(explicitHome, {});
   if (existing) return existing;
+  ensureDirectory(home);
+  chmodSync(home, 0o700);
   const config = mergeConfig(
     { ...defaultConfig, backend: { kind: 'local' }, workspaceId: ulid() },
     undefined,
@@ -100,3 +101,28 @@ export async function openLocalService(
   await client.init();
   return client;
 }
+
+export async function openLocalOwnerService(home?: string): Promise<SynomemClient> {
+  ensureLocalStore(home);
+  const client = createLocalOwnerClient({ ...(home ? { home } : {}), actor: LOCAL_OPERATOR });
+  await client.init();
+  return client;
+}
+
+/** Filesystem-owner recovery path: no migration, normalization or writes. */
+export function exportRawLocalEvents(home?: string, format: 'json' | 'jsonl' = 'jsonl'): string {
+  const root = resolveHome(home);
+  const databasePath = join(root, 'synomem.sqlite3');
+  assertNoSymlinkEscape(root, databasePath);
+  const database = new DatabaseSync(databasePath, { readOnly: true });
+  try {
+    const rows = database.prepare('SELECT payload FROM events ORDER BY rowid').all() as Array<{
+      payload: string;
+    }>;
+    return format === 'jsonl'
+      ? rows.map((row) => row.payload).join('\n') + (rows.length ? '\n' : '')
+      : `[${rows.map((row) => row.payload).join(',\n')}]\n`;
+  } finally {
+    database.close();
+  }
+}

package/src/bookmarks.ts

@@ -0,0 +1,127 @@
+import type { ActorIdentity, ItemSummary } from './types.js';
+import type { ActorRef } from './policy.js';
+import type { NotificationSql } from './notifications.js';
+import { cursorFilter } from './cursors.js';
+export interface BookmarkInput {
+  after?: string;
+  limit?: number;
+}
+export interface BookmarkPage {
+  items: Array<{ root: Pick<ItemSummary, 'id' | 'kind' | 'title'>; savedAt: string }>;
+  hasMore: boolean;
+  nextCursor?: string;
+  watermark: string;
+}
+export interface BookmarkRepository {
+  set(rootId: string, actor: ActorRef, present: boolean): Promise<void>;
+  has(rootId: string, actor: ActorRef): Promise<boolean>;
+  list(input: BookmarkInput, actor: ActorIdentity): Promise<BookmarkPage>;
+}
+export const bookmarkTables = `
+CREATE TABLE bookmark_sequences(workspace_id TEXT PRIMARY KEY,last_sequence BIGINT NOT NULL);
+CREATE TABLE bookmarks(workspace_id TEXT NOT NULL,actor_kind TEXT NOT NULL,actor_id TEXT NOT NULL,root_id TEXT NOT NULL,saved_at TEXT NOT NULL,saved_sequence BIGINT NOT NULL,PRIMARY KEY(workspace_id,actor_kind,actor_id,root_id));
+CREATE INDEX bookmarks_actor_sequence ON bookmarks(workspace_id,actor_kind,actor_id,saved_sequence);
+`;
+export class SqlBookmarkRepository implements BookmarkRepository {
+  constructor(private readonly sql: NotificationSql) {}
+  async has(rootId: string, actor: ActorRef): Promise<boolean> {
+    return (
+      (
+        await this.sql.query(
+          'SELECT 1 FROM bookmarks WHERE workspace_id=? AND actor_kind=? AND actor_id=? AND root_id=?',
+          [this.sql.workspaceId, actor.kind, actor.id, rootId],
+        )
+      ).length > 0
+    );
+  }
+  async set(rootId: string, actor: ActorRef, present: boolean): Promise<void> {
+    if (!present) {
+      await this.sql.execute(
+        'DELETE FROM bookmarks WHERE workspace_id=? AND actor_kind=? AND actor_id=? AND root_id=?',
+        [this.sql.workspaceId, actor.kind, actor.id, rootId],
+      );
+      return;
+    }
+    if (await this.has(rootId, actor)) return;
+    const counter = (
+      await this.sql.query(
+        'INSERT INTO bookmark_sequences(workspace_id,last_sequence) VALUES(?,1) ON CONFLICT(workspace_id) DO UPDATE SET last_sequence=bookmark_sequences.last_sequence+1 RETURNING last_sequence',
+        [this.sql.workspaceId],
+      )
+    )[0]!;
+    await this.sql.execute(
+      'INSERT INTO bookmarks(workspace_id,actor_kind,actor_id,root_id,saved_at,saved_sequence) VALUES(?,?,?,?,?,?) ON CONFLICT(workspace_id,actor_kind,actor_id,root_id) DO NOTHING',
+      [
+        this.sql.workspaceId,
+        actor.kind,
+        actor.id,
+        rootId,
+        new Date().toISOString(),
+        String(counter.last_sequence),
+      ],
+    );
+  }
+  async list(input: BookmarkInput, actor: ActorIdentity): Promise<BookmarkPage> {
+    const maximum = String(
+      (
+        await this.sql.query(
+          'SELECT COALESCE((SELECT last_sequence FROM bookmark_sequences WHERE workspace_id=?),0) AS max',
+          [this.sql.workspaceId],
+        )
+      )[0]!.max,
+    );
+    const binding = {
+      purpose: 'bookmarks',
+      workspaceId: this.sql.workspaceId,
+      actor,
+      filter: cursorFilter({}),
+    };
+    const codec = this.sql.codec();
+    const position = input.after ? codec.decode(input.after, binding, maximum) : undefined;
+    const high = position?.watermark ?? maximum;
+    const policy = this.sql.visibility(actor);
+    const limit = input.limit ?? 20;
+    const rows = await this.sql.query(
+      `SELECT b.saved_sequence,b.saved_at,i.item_id,i.kind,i.title FROM bookmarks b JOIN items_current i ON i.workspace_id=b.workspace_id AND i.item_id=b.root_id WHERE b.workspace_id=? AND b.actor_kind=? AND b.actor_id=? AND b.saved_sequence>? AND b.saved_sequence<=? AND (${policy.sql}) ORDER BY b.saved_sequence LIMIT ?`,
+      [
+        this.sql.workspaceId,
+        actor.kind,
+        actor.id,
+        position?.sequence ?? '0',
+        high,
+        ...policy.values,
+        limit + 1,
+      ],
+    );
+    const items: BookmarkPage['items'] = [];
+    let bytes = 2048;
+    for (const row of rows.slice(0, limit)) {
+      const entry = {
+        root: {
+          id: String(row.item_id),
+          kind: String(row.kind) as ItemSummary['kind'],
+          title: String(row.title),
+        },
+        savedAt: String(row.saved_at),
+      };
+      const size = Buffer.byteLength(JSON.stringify(entry));
+      if (items.length && bytes + size > 24576) break;
+      items.push(entry);
+      bytes += size;
+    }
+    const hasMore = rows.length > items.length;
+    return {
+      items,
+      hasMore,
+      ...(hasMore
+        ? {
+            nextCursor: codec.encode(binding, {
+              sequence: String(rows[items.length - 1]!.saved_sequence),
+              watermark: high,
+            }),
+          }
+        : {}),
+      watermark: codec.encode(binding, { sequence: high, watermark: high }),
+    };
+  }
+}