@treenity/core 1.0.48 → 3.0.1

package/src/server/actions.test.ts

@@ -0,0 +1,272 @@
+import { registerType } from '#comp';
+import { createNode, isComponent, normalizeType, resolve, type NodeData } from '#core';
+import { clearRegistry } from '#core/index.test';
+import { createMemoryTree } from '#tree';
+import assert from 'node:assert/strict';
+import { beforeEach, describe, it } from 'node:test';
+import { collectSiblings, createNodeHandle, executeAction, registerBuiltinActions } from './actions';
+
+// ── Component classes ──
+
+class Metadata {
+  title = '';
+  description = '';
+
+  async rename({ title }: { title: string }) {
+    this.title = title;
+  }
+
+  async clear() {
+    this.title = '';
+    this.description = '';
+  }
+}
+
+class Status {
+  value = 'draft';
+
+  async publish() {
+    this.value = 'published';
+  }
+
+  async draft() {
+    this.value = 'draft';
+  }
+}
+
+// ── Tests ──
+
+describe('defineComponent', () => {
+  beforeEach(() => {
+    clearRegistry();
+  });
+
+  function setup() {
+    registerType('metadata', Metadata);
+    registerType('status', Status);
+  }
+
+  it('registers methods as action:name', () => {
+    setup();
+    assert.ok(resolve('metadata', 'action:rename'));
+    assert.ok(resolve('metadata', 'action:clear'));
+    assert.ok(resolve('status', 'action:publish'));
+  });
+
+  it('stores class → type mapping', () => {
+    setup();
+    assert.equal(normalizeType(Metadata), 't.metadata');
+    assert.equal(normalizeType(Status), 't.status');
+  });
+
+  it('action mutates component via this', () => {
+    setup();
+    const comp = { $type: 'metadata', title: 'old', description: 'desc' } as any;
+    resolve('metadata', 'action:rename')!({ comp } as any, { title: 'new' });
+    assert.equal(comp.title, 'new');
+    assert.equal(comp.description, 'desc');
+  });
+
+  it('end-to-end: simulate trpc execute', async () => {
+    setup();
+    const store = createMemoryTree();
+    await store.set(
+      createNode('/p', 'page', {}, {
+        metadata: { $type: 'metadata', title: 'old', description: 'x' },
+        status: { $type: 'status', value: 'draft' },
+      }),
+    );
+
+    async function execute(path: string, component: string, action: string, data?: unknown) {
+      const n = (await store.get(path))!;
+      const cv = n[component];
+      if (!isComponent(cv)) throw new Error(`Component "${component}" not found`);
+      const siblings = collectSiblings(n, component);
+      resolve(cv.$type, `action:${action}`)!({ node: n, comp: cv, siblings, store } as any, data);
+      await store.set(n);
+    }
+
+    await execute('/p', 'metadata', 'rename', { title: 'new' });
+    await execute('/p', 'status', 'publish');
+
+    const result = (await store.get('/p'))!;
+    assert.equal((result['metadata'] as any).title, 'new');
+    assert.equal((result['status'] as any).value, 'published');
+  });
+
+  it('node.get(Class).action() — typed client proxy', async () => {
+    setup();
+    const calls: any[] = [];
+    const mockStream = (_input: any) => (async function* () {})();
+    const node = createNodeHandle(async (input: any) => {
+      calls.push(input);
+    }, mockStream);
+
+    const page = node('/pages/main');
+    await page.get(Metadata).rename({ title: 'test' });
+    await page.get(Status).publish();
+
+    assert.equal(calls.length, 2);
+    assert.deepEqual(calls[0], {
+      path: '/pages/main',
+      type: 't.metadata',
+      key: undefined,
+      action: 'rename',
+      data: { title: 'test' },
+    });
+    assert.deepEqual(calls[1], {
+      path: '/pages/main',
+      type: 't.status',
+      key: undefined,
+      action: 'publish',
+      data: undefined,
+    });
+  });
+
+  it('defineComponent with needs option', () => {
+    registerType('metadata', Metadata, { needs: ['status'] });
+    registerType('status', Status);
+
+    const node = createNode('/p', 'page', {}, {
+      metadata: { $type: 'metadata', title: 'old', description: 'x' },
+      status: { $type: 'status', value: 'draft' },
+    });
+    const siblings = collectSiblings(node, 'metadata');
+    assert.equal(Object.keys(siblings).length, 1);
+    assert.equal((siblings.status as any).value, 'draft');
+  });
+
+  it('action receives deps as second arg', () => {
+    class Article {
+      title = '';
+
+      publishAndRename({ title }: { title: string }, deps: { status: any }) {
+        this.title = title;
+        deps.status.value = 'published';
+      }
+    }
+
+    registerType('article', Article, { needs: ['status'] });
+    registerType('status', Status);
+
+    const node = createNode('/a', 'page', {}, {
+      article: { $type: 'article', title: 'old' },
+      status: { $type: 'status', value: 'draft' },
+    });
+
+    const comp = node['article'] as any;
+    const deps = collectSiblings(node, 'article');
+    resolve(comp.$type, 'action:publishAndRename')!({ node, comp, deps } as any, {
+      title: 'new',
+    });
+
+    assert.equal(comp.title, 'new');
+    assert.equal((node['status'] as any).value, 'published');
+  });
+
+  it('patch action: shallow fields', async () => {
+    registerBuiltinActions();
+    const store = createMemoryTree();
+    await store.set(createNode('/n', 'mytype', { title: 'old', count: 1 }));
+
+    await executeAction(store, '/n', undefined, undefined, 'patch', { title: 'new', count: 2 });
+
+    const result = (await store.get('/n'))!;
+    assert.equal(result.title, 'new');
+    assert.equal(result.count, 2);
+  });
+
+  it('patch action: deep merges nested objects', async () => {
+    registerBuiltinActions();
+    const store = createMemoryTree();
+    await store.set(createNode('/n', 'mytype', {
+      mesh: { $type: 't3d.mesh', width: 5, height: 10 },
+    }));
+
+    await executeAction(store, '/n', undefined, undefined, 'patch', {
+      mesh: { width: 20 },
+    });
+
+    const result = (await store.get('/n'))!;
+    const mesh = result.mesh as any;
+    assert.equal(mesh.width, 20);
+    assert.equal(mesh.height, 10);
+    assert.equal(mesh.$type, 't3d.mesh');
+  });
+
+  it('patch action: guards $ fields', async () => {
+    registerBuiltinActions();
+    const store = createMemoryTree();
+    await store.set(createNode('/n', 'mytype', { title: 'ok' }));
+
+    await executeAction(store, '/n', undefined, undefined, 'patch', {
+      $type: 'hacked', $path: '/evil', title: 'patched',
+    });
+
+    const result = (await store.get('/n'))!;
+    assert.equal(result.$type, 't.mytype');
+    assert.equal(result.$path, '/n');
+    assert.equal(result.title, 'patched');
+  });
+
+  it('patch action: replaces arrays wholesale', async () => {
+    registerBuiltinActions();
+    const store = createMemoryTree();
+    await store.set(createNode('/n', 'mytype', { tags: ['a', 'b'] }));
+
+    await executeAction(store, '/n', undefined, undefined, 'patch', { tags: ['c'] });
+
+    const result = (await store.get('/n'))!;
+    assert.deepEqual(result.tags, ['c']);
+  });
+
+  it('end-to-end execute with needs injection', async () => {
+    class Article {
+      title = '';
+
+      publishAndRename({ title }: { title: string }, deps: { status: any }) {
+        this.title = title;
+        deps.status.value = 'published';
+      }
+    }
+
+    registerType('article', Article, { needs: ['status'] });
+    registerType('status', Status);
+
+    const store = createMemoryTree();
+    await store.set(
+      createNode('/a', 'page', {}, {
+        article: { $type: 'article', title: 'old' },
+        status: { $type: 'status', value: 'draft' },
+      }),
+    );
+
+    const node = (await store.get('/a'))!;
+    const comp = node['article'] as any;
+    const deps = collectSiblings(node, 'article');
+    resolve(comp.$type, 'action:publishAndRename')!({ node, comp, deps, store } as any, {
+      title: 'new',
+    });
+    await store.set(node);
+
+    const result = (await store.get('/a'))!;
+    assert.equal((result['article'] as any).title, 'new');
+    assert.equal((result['status'] as any).value, 'published');
+  });
+
+  it('executeAction resolves dotless node.$type against normalized componentType', async () => {
+    // Regression: normalizeType('autostart') → 't.autostart', but node.$type is 'autostart'.
+    // resolveActionHandler compared raw node.$type against normalized componentType — mismatch.
+    class Svc {
+      async ping() { return 'pong'; }
+    }
+    registerType('svc', Svc);
+
+    const store = createMemoryTree();
+    await store.set({ $path: '/s', $type: 'svc' } as NodeData);
+
+    // componentType = 't.svc' (normalized), node.$type = 'svc' (raw) — must match
+    const result = await executeAction(store, '/s', 't.svc', undefined, 'ping', undefined);
+    assert.equal(result, 'pong');
+  });
+});

package/src/server/actions.ts

@@ -0,0 +1,274 @@
+// Treenity Actions — Layer 4
+// Server-specific: ActionCtx, SchemaHandler, client proxy
+// Component registration lives in @/comp
+
+import { chain, type Chain } from '#chain';
+import { Class, type TypeProxy } from '#comp';
+import { makeTypedProxy, type ExecuteFn, type StreamFn } from '#comp/handle';
+import { collectDeps as _collectDeps, type ResolvedDeps } from '#comp/needs';
+import { type ComponentData, getComponentField, isComponent, type NodeData, register, resolve } from '#core';
+import { type Tree } from '#tree';
+import { createDraft, enablePatches, finishDraft, type Patch } from 'immer';
+import { OpError } from './errors';
+
+export type NodeHandle = ReturnType<typeof serverNodeHandle>;
+
+/** @opaque Runtime-injected, not part of public schema */
+export type ActionCtx = {
+  node: NodeData;
+  store: Tree;
+  signal: AbortSignal;
+  /** Typed client for cross-node action calls: ctx.nc(path).get(Type).method(data) */
+  nc: NodeHandle;
+  comp?: ComponentData;
+  deps?: ResolvedDeps;
+};
+
+// ── Client proxy ──
+
+export type { ExecuteInput } from '#comp/handle';
+
+export function createNodeHandle(
+  execute: ExecuteFn,
+  stream: StreamFn,
+  getNode?: (path: string) => NodeData | undefined,
+) {
+  return (path: string) => ({
+    get<T extends object>(cls: Class<T>, key?: string): Chain<TypeProxy<T>> {
+      return chain(makeTypedProxy(getNode?.(path), cls, path, execute, stream, key)) as Chain<TypeProxy<T>>;
+    },
+  });
+}
+// Server-side typed node client: wraps executeAction/executeStream into createNodeHandle.
+// Usage: const nc = serverNodeHandle(store); await nc(path).get(MyComp).myMethod();
+export function serverNodeHandle(store: Tree) {
+  return createNodeHandle(
+    (input) => executeAction(store, input.path, input.type, input.key, input.action, input.data),
+    (input) => executeStream(store, input.path, input.type, input.key, input.action, input.data),
+  );
+}
+
+export { collectSiblings, collectDeps } from '#comp/needs';
+export { registerActionNeeds, getActionNeeds } from '#comp/needs';
+
+// ── Server-side operations ──
+// Single entry point for tRPC, MCP, cook-bot, services — no boilerplate.
+// All ops throw OpError for domain errors (NOT_FOUND, BAD_REQUEST, CONFLICT).
+enablePatches();
+
+// Action timeout: env-configurable, default 5 min (was 30s)
+const ACTION_TIMEOUT = Number(process.env.ACTION_TIMEOUT) || 300_000;
+const STREAM_TIMEOUT = Number(process.env.STREAM_TIMEOUT) || 600_000;
+
+// ── Shared resolution: find handler + component for any action call ──
+// Resolution order:
+//   key given → node[key], verify $type === type (if type given)
+//   type given, no key → scan components for first matching $type
+//   neither → node.$type, then scan components for matching action handler
+
+type ResolvedAction = {
+  node: NodeData;
+  handler: (ctx: ActionCtx, data: unknown) => unknown;
+  type: string;
+  comp: ComponentData | undefined;
+  deps: ResolvedDeps;
+  fieldKey: string | undefined;
+};
+
+// Dynamic actions: load from /sys/types/{ns}/{name} node's `actions` component.
+// Code is compiled with new Function, registered for future calls.
+// Format: actions.{name} = "const node = ...; return result;"  (async function body)
+async function loadDynamicAction(
+  store: Tree, type: string, action: string,
+): Promise<((ctx: ActionCtx, data: unknown) => unknown) | null> {
+  if (!type.includes('.')) return null;
+
+  const typePath = `/sys/types/${type.replace(/\./g, '/')}`;
+  const typeNode = await store.get(typePath);
+  const actionCode = (typeNode as any)?.actions?.[action];
+  if (!actionCode || typeof actionCode !== 'string') return null;
+
+  try {
+    const fn = new Function('ctx', 'data', `return (async () => { ${actionCode} })()`) as
+      (ctx: ActionCtx, data: unknown) => unknown;
+    register(type, `action:${action}`, fn);
+    console.log(`[uix] loaded dynamic action "${action}" for "${type}"`);
+    return fn;
+  } catch (err: any) {
+    console.warn(`[uix] failed to compile action "${action}" for "${type}":`, err.message);
+    return null;
+  }
+}
+
+async function resolveActionHandler(
+  store: Tree,
+  path: string,
+  componentType: string | undefined,
+  componentKey: string | undefined,
+  action: string,
+): Promise<ResolvedAction> {
+  const node = await store.get(path);
+  if (!node) throw new OpError('NOT_FOUND', `Node not found: ${path}`);
+
+  const [comp, fieldKey] = getComponentField(node, componentType ?? 't.any', componentKey) ?? [];
+  if (!isComponent(comp)) throw new OpError('NOT_FOUND', `Component "${componentKey ?? componentType}" not found on ${path}`);
+
+  const type = comp.$type;
+
+  let deps: ResolvedDeps = await _collectDeps(node, fieldKey!, action, store);
+
+  let handler = resolve(type, `action:${action}`);
+
+  // Fallback: try loading dynamic action from type definition node
+  if (!handler) handler = await loadDynamicAction(store, type, action);
+  if (!handler) throw new OpError('BAD_REQUEST', `No action "${action}" for type "${type}"`);
+
+  return { node, handler, type, comp, deps, fieldKey };
+}
+
+// ── executeAction: mutating action with Immer draft + patch collection ──
+// Patches attached as $patches for subscription layer (CDC Matrix in sub.ts).
+// Pure actions (no state changes) skip persist — patches.length === 0.
+
+export async function executeAction(
+  store: Tree,
+  path: string,
+  componentType: string | undefined,
+  componentKey: string | undefined,
+  action: string,
+  data?: unknown,
+): Promise<unknown> {
+  const { node, handler, type, deps, fieldKey } = await resolveActionHandler(
+    store, path, componentType, componentKey, action,
+  );
+
+  // Pre/post condition checking (Design by Contract)
+  const schemaHandler = resolve(type, 'schema') as (() => any) | null;
+  const methodSchema = schemaHandler?.()?.methods?.[action];
+  const preFields: string[] = methodSchema?.pre ?? [];
+  const postFields: string[] = methodSchema?.post ?? [];
+  const target = fieldKey ? node[fieldKey] as Record<string, unknown> : node as Record<string, unknown>;
+
+  for (const f of preFields) {
+    const v = target[f];
+    if (v === undefined || v === null || v === '' || v === 0) {
+      console.warn(`[pre] ${type}.${action}: field "${f}" is empty`);
+    }
+  }
+
+  const postSnap = Object.fromEntries(postFields.map(f => [f, target[f]]));
+
+  const draft = createDraft(node);
+  // comp must be the draft version so Immer captures mutations via `this.*`
+  const dc = fieldKey ? draft[fieldKey] : undefined;
+  const draftComp = isComponent(dc) ? dc as ComponentData : undefined;
+  const nc = serverNodeHandle(store);
+  const actx: ActionCtx = { node: draft, comp: draftComp, deps, store, signal: AbortSignal.timeout(ACTION_TIMEOUT), nc };
+  const result = await handler(actx, data ?? {});
+
+  let patches: Patch[] = [];
+  const nextNode = finishDraft(draft, (p) => { patches = p });
+
+  const postTarget = fieldKey ? nextNode[fieldKey] as Record<string, unknown> : nextNode as Record<string, unknown>;
+  for (const f of postFields) {
+    if (postTarget[f] === postSnap[f]) {
+      console.warn(`[post] ${type}.${action}: field "${f}" unchanged`);
+    }
+  }
+
+  if (patches.length > 0) await store.set({ ...nextNode, $patches: patches } as NodeData);
+  return result;
+}
+
+// ── executeStream: generator action — yields multiple values, no Immer draft ──
+// Generator actions persist via store.set() directly inside the generator body.
+
+export async function* executeStream(
+  store: Tree,
+  path: string,
+  componentType: string | undefined,
+  componentKey: string | undefined,
+  action: string,
+  data?: unknown,
+  signal?: AbortSignal,
+): AsyncGenerator<unknown> {
+  const { node, handler, comp, deps } = await resolveActionHandler(
+    store, path, componentType, componentKey, action,
+  );
+  // comp is already node[fieldKey] from resolution — no Immer draft needed for generators
+  const nc = serverNodeHandle(store);
+  const actx: ActionCtx = { node, comp, deps, store, signal: signal ?? AbortSignal.timeout(STREAM_TIMEOUT), nc };
+  const result = handler(actx, data ?? {});
+  if (!result || typeof (result as any)[Symbol.asyncIterator] !== 'function')
+    throw new OpError('BAD_REQUEST', `Action "${action}" is not a generator`);
+  yield* result as AsyncIterable<unknown>;
+}
+
+// ── setComponent: single component update with OCC ──
+
+export async function setComponent(
+  store: Tree,
+  path: string,
+  name: string,
+  data: Record<string, unknown>,
+  rev?: number,
+): Promise<void> {
+  const node = await store.get(path);
+  if (!node) throw new OpError('NOT_FOUND', `Node not found: ${path}`);
+
+  if (rev != null && node.$rev != null && rev !== node.$rev)
+    throw new OpError('CONFLICT', `Stale revision: expected ${rev}, got ${node.$rev}`);
+
+  node[name] = data;
+  await store.set(node);
+}
+
+// ── applyTemplate: copy template children to target path ──
+
+export async function applyTemplate(
+  store: Tree,
+  templatePath: string,
+  targetPath: string,
+): Promise<{ applied: string; blocks: number }> {
+  const tmpl = await store.get(templatePath);
+  if (!tmpl) throw new OpError('NOT_FOUND', `Template not found: ${templatePath}`);
+
+  const { items: blocks } = await store.getChildren(templatePath);
+  const { items: existing } = await store.getChildren(targetPath);
+
+  for (const child of existing) await store.remove(child.$path);
+
+  for (const block of blocks) {
+    const bname = block.$path.slice(block.$path.lastIndexOf('/') + 1);
+    const bpath = targetPath === '/' ? `/${bname}` : `${targetPath}/${bname}`;
+    const { $rev, ...rest } = block;
+    await store.set({ ...rest, $path: bpath });
+  }
+
+  return { applied: tmpl.$path, blocks: blocks.length };
+}
+
+// ── Generic patch action — deep merge data into node (Immer draft) ──
+// Registered on 'default' so every type inherits it via resolve fallback.
+// Guards $ fields. Deep-merges objects, replaces arrays/primitives.
+
+function deepAssign(target: any, source: Record<string, unknown>) {
+  for (const [k, v] of Object.entries(source)) {
+    if (k.startsWith('$')) continue;
+    if (v && typeof v === 'object' && !Array.isArray(v)
+      && target[k] && typeof target[k] === 'object' && !Array.isArray(target[k])) {
+      deepAssign(target[k], v as Record<string, unknown>);
+    } else {
+      target[k] = v;
+    }
+  }
+}
+
+export function registerBuiltinActions() {
+  register('default', 'action:patch', (ctx: ActionCtx, data: unknown) => {
+    if (!data || typeof data !== 'object') throw new OpError('BAD_REQUEST', 'patch: data must be an object');
+    deepAssign(ctx.node, data as Record<string, unknown>);
+  });
+}
+
+registerBuiltinActions();

package/src/server/agent-sub.test.ts

@@ -0,0 +1,90 @@
+// Focused reproduction test: new child created via action → watcher notifies
+// Tests the exact agent scenario: action:task creates /agent/tasks/t-xxx,
+// user watching /agent/tasks prefix should get the event.
+
+import { createNode, register } from '#core';
+import { clearRegistry } from '#core/index.test';
+import { createMemoryTree } from '#tree';
+import assert from 'node:assert/strict';
+import { beforeEach, describe, it } from 'node:test';
+import { type ActionCtx, executeAction } from './actions';
+import { type NodeEvent, withSubscriptions } from './sub';
+import { createWatchManager } from './watch';
+
+describe('Agent task subscription', () => {
+  beforeEach(() => clearRegistry());
+
+  it('new child created via action triggers prefix watcher', async () => {
+    // Register the action (simulates agent's action:task)
+    register('agent.config', 'action:task', async (ctx: ActionCtx, data: { prompt: string }) => {
+      const id = `t-${Date.now()}`;
+      const taskPath = `${ctx.node.$path}/tasks/${id}`;
+      await ctx.store.set(createNode(taskPath, 'agent.task', {
+        prompt: data.prompt,
+        status: 'pending',
+        createdAt: Date.now(),
+      }));
+      return { taskPath };
+    });
+
+    // Build store pipeline: memory → subscriptions → watcher
+    const mem = createMemoryTree();
+    const watcher = createWatchManager();
+    const store = withSubscriptions(mem, (e) => watcher.notify(e));
+
+    // Seed the agent config node
+    await store.set(createNode('/agent', 'agent.config', { systemPrompt: 'test' }));
+    await store.set(createNode('/agent/tasks', 'dir'));
+
+    // Simulate user: connect SSE + register prefix watch
+    const events: NodeEvent[] = [];
+    watcher.connect('conn1', 'user1', (e) => events.push(e));
+    watcher.watch('user1', ['/agent/tasks'], { children: true, autoWatch: true });
+
+    // Execute the action (same as trpc.execute.mutate)
+    const result = await executeAction(store, '/agent', undefined, undefined, 'task', { prompt: 'test task' });
+    assert.ok(result && typeof (result as any).taskPath === 'string');
+
+    // Verify: the watcher should have received the new task event
+    assert.equal(events.length, 1, 'watcher should have received exactly 1 event');
+    assert.equal(events[0].type, 'set', 'event should be of type "set"');
+    assert.ok((events[0] as any).path.startsWith('/agent/tasks/t-'), 'event path should be the new task');
+    assert.equal((events[0] as any).node.$type, 'agent.task', 'node should have correct $type');
+  });
+
+  it('new child event includes correct node data for cache.put', async () => {
+    register('agent.config', 'action:task', async (ctx: ActionCtx, data: { prompt: string }) => {
+      const taskPath = `${ctx.node.$path}/tasks/t-1`;
+      await ctx.store.set(createNode(taskPath, 'agent.task', {
+        prompt: data.prompt,
+        status: 'pending',
+        createdAt: 12345,
+      }));
+      return { taskPath };
+    });
+
+    const mem = createMemoryTree();
+    const watcher = createWatchManager();
+    const store = withSubscriptions(mem, (e) => watcher.notify(e));
+
+    await store.set(createNode('/agent', 'agent.config'));
+    await store.set(createNode('/agent/tasks', 'dir'));
+
+    const events: NodeEvent[] = [];
+    watcher.connect('c1', 'u1', (e) => events.push(e));
+    watcher.watch('u1', ['/agent/tasks'], { children: true, autoWatch: true });
+
+    await executeAction(store, '/agent', undefined, undefined, 'task', { prompt: 'hello' });
+
+    // Simulate what the client does: reconstruct the node from the event
+    assert.equal(events.length, 1);
+    const evt = events[0] as { type: 'set'; path: string; node: any };
+    const reconstructed = { $path: evt.path, ...evt.node };
+
+    assert.equal(reconstructed.$path, '/agent/tasks/t-1');
+    assert.equal(reconstructed.$type, 'agent.task');
+    assert.equal(reconstructed.prompt, 'hello');
+    assert.equal(reconstructed.status, 'pending');
+    assert.equal(reconstructed.createdAt, 12345);
+  });
+});