[Init] Initial commit - NetMesh terminal manager

application/state/pluginTerminalProviderRegistry.test.ts

@@ -0,0 +1,432 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+
+import {
+  collectPluginTerminalProviderKinds,
+  isPluginTerminalProviderKindAvailable,
+  PluginTerminalProviderAvailability,
+  PluginTerminalProviderRegistry,
+} from './pluginTerminalProviderRegistry.ts';
+
+const session: NetcattyTerminalSessionSnapshot = {
+  sessionId: 'session-1',
+  protocol: 'ssh',
+  status: 'connected',
+};
+
+test('terminal Provider availability fails closed before or after failed enumeration', async () => {
+  assert.equal(isPluginTerminalProviderKindAvailable(null, 'terminal.matcher'), false);
+  const registry = new PluginTerminalProviderRegistry({
+    async listPluginTerminalProviders() { throw new Error('bridge unavailable'); },
+    async providePluginTerminal() { return []; },
+    async cancelPluginTerminalRequest() { return false; },
+    async publishPluginTerminalSessionEvent() { return []; },
+  });
+  const kinds = await collectPluginTerminalProviderKinds(registry, [
+    'terminal.matcher',
+    'terminal.background',
+  ]);
+  assert.equal(isPluginTerminalProviderKindAvailable(kinds, 'terminal.matcher'), false);
+  assert.equal(isPluginTerminalProviderKindAvailable(kinds, 'terminal.background'), false);
+  registry.dispose();
+});
+
+test('terminal Provider availability ignores an older enumeration that finishes last', async () => {
+  let resolveOlder: ((providers: NetcattyTerminalProviderContribution[]) => void) | undefined;
+  const olderRegistry = new PluginTerminalProviderRegistry({
+    listPluginTerminalProviders() {
+      return new Promise((resolve) => { resolveOlder = resolve; });
+    },
+    async providePluginTerminal() { return []; },
+    async cancelPluginTerminalRequest() { return false; },
+    async publishPluginTerminalSessionEvent() { return []; },
+  });
+  const newerRegistry = new PluginTerminalProviderRegistry({
+    async listPluginTerminalProviders() {
+      return [{
+        pluginId: 'com.example.matcher',
+        pluginVersion: '1.0.0',
+        pluginDisplayName: 'Matcher',
+        provider: {
+          id: 'com.example.matcher.output',
+          label: 'Output matcher',
+          kind: 'terminal.matcher',
+        },
+      }];
+    },
+    async providePluginTerminal() { return []; },
+    async cancelPluginTerminalRequest() { return false; },
+    async publishPluginTerminalSessionEvent() { return []; },
+  });
+  const availability = new PluginTerminalProviderAvailability();
+  const older = availability.refresh(olderRegistry, ['terminal.matcher']);
+  const newer = availability.refresh(newerRegistry, ['terminal.matcher']);
+  assert.equal(await newer, true);
+  assert.equal(availability.has('terminal.matcher'), true);
+  resolveOlder?.([]);
+  assert.equal(await older, false);
+  assert.equal(availability.has('terminal.matcher'), true);
+  olderRegistry.dispose();
+  newerRegistry.dispose();
+});
+
+test('terminal Provider registry coalesces immutable enumeration until contributions change', async () => {
+  let changed: (() => void) | undefined;
+  let listCalls = 0;
+  const resolvers: Array<(providers: NetcattyTerminalProviderContribution[]) => void> = [];
+  const registry = new PluginTerminalProviderRegistry({
+    listPluginTerminalProviders() {
+      listCalls += 1;
+      return new Promise((resolve) => { resolvers.push(resolve); });
+    },
+    async providePluginTerminal() { return []; },
+    async cancelPluginTerminalRequest() { return false; },
+    async publishPluginTerminalSessionEvent() { return []; },
+    onPluginContributionsChanged(listener) {
+      changed = listener;
+      return () => {};
+    },
+  });
+  const first = registry.listProviders({ kind: 'terminal.matcher' });
+  const duplicate = registry.listProviders({ kind: 'terminal.matcher' });
+  assert.equal(listCalls, 1);
+  resolvers[0]?.([]);
+  assert.strictEqual(await first, await duplicate);
+  assert.strictEqual(await registry.listProviders({ kind: 'terminal.matcher' }), await first);
+  assert.equal(listCalls, 1);
+
+  changed?.();
+  const refreshed = registry.listProviders({ kind: 'terminal.matcher' });
+  assert.equal(listCalls, 2);
+  resolvers[1]?.([]);
+  await refreshed;
+  registry.dispose();
+});
+
+test('terminal Provider registry suppresses repeated lifecycle RPC after the bridge is unavailable', async () => {
+  let changed: (() => void) | undefined;
+  let listCalls = 0;
+  let lifecycleCalls = 0;
+  const registry = new PluginTerminalProviderRegistry({
+    async listPluginTerminalProviders() {
+      listCalls += 1;
+      throw new Error('PLUGIN_DEVELOPMENT_DISABLED');
+    },
+    async providePluginTerminal() { return []; },
+    async cancelPluginTerminalRequest() { return false; },
+    async publishPluginTerminalSessionEvent() {
+      lifecycleCalls += 1;
+      throw new Error('PLUGIN_DEVELOPMENT_DISABLED');
+    },
+    onPluginContributionsChanged(listener) {
+      changed = listener;
+      return () => {};
+    },
+  });
+
+  await assert.rejects(registry.listProviders({ kind: 'terminal.link' }), /PLUGIN_DEVELOPMENT_DISABLED/);
+  assert.deepEqual(await registry.listProviders({ kind: 'terminal.link' }), []);
+  assert.equal(listCalls, 1);
+  await registry.publishSessionEvent({ type: 'created', session });
+  await registry.publishSessionEvent({ type: 'titleChanged', session: { ...session, title: 'ready' } });
+  assert.equal(lifecycleCalls, 0);
+
+  changed?.();
+  await assert.rejects(
+    registry.publishSessionEvent({ type: 'cwdChanged', session: { ...session, cwd: '/work' } }),
+    /PLUGIN_DEVELOPMENT_DISABLED/,
+  );
+  await registry.publishSessionEvent({ type: 'resized', session: { ...session, cols: 80, rows: 24 } });
+  assert.equal(lifecycleCalls, 1);
+  registry.dispose();
+});
+
+test('terminal Provider registry cancels superseded requests and suppresses stale results', async () => {
+  const cancellations: string[] = [];
+  const resolvers: Array<(value: ReadonlyArray<NetcattyTerminalProviderResult>) => void> = [];
+  const registry = new PluginTerminalProviderRegistry({
+    async listPluginTerminalProviders() { return []; },
+    providePluginTerminal() {
+      return new Promise((resolve) => resolvers.push(resolve));
+    },
+    async cancelPluginTerminalRequest(requestId) { cancellations.push(requestId); return true; },
+    async publishPluginTerminalSessionEvent() { return []; },
+  });
+
+  const first = registry.request({
+    kind: 'terminal.completion',
+    operation: 'provideCompletions',
+    session,
+    payload: { input: 'g' },
+  });
+  const second = registry.request({
+    kind: 'terminal.completion',
+    operation: 'provideCompletions',
+    session,
+    payload: { input: 'gi' },
+  });
+  await new Promise((resolve) => setImmediate(resolve));
+  assert.equal(cancellations.length, 1);
+  resolvers[1]([]);
+  const secondResult = await second;
+  resolvers[0]([]);
+  const firstResult = await first;
+  assert.equal(secondResult.stale, false);
+  assert.equal(firstResult.stale, true);
+  assert.deepEqual(firstResult.results, []);
+});
+
+test('terminal Provider registry aborts an in-flight bridge request and settles stale', async () => {
+  const cancellations: string[] = [];
+  const requests: NetcattyTerminalProviderRequest[] = [];
+  const controller = new AbortController();
+  const registry = new PluginTerminalProviderRegistry({
+    async listPluginTerminalProviders() { return []; },
+    providePluginTerminal(request) {
+      requests.push(request);
+      return new Promise(() => {});
+    },
+    async cancelPluginTerminalRequest(requestId) { cancellations.push(requestId); return true; },
+    async publishPluginTerminalSessionEvent() { return []; },
+  });
+
+  const pending = registry.request({
+    kind: 'terminal.completion',
+    operation: 'provideCompletions',
+    session,
+  }, { signal: controller.signal });
+  await new Promise((resolve) => setImmediate(resolve));
+  assert.equal(requests.length, 1);
+
+  controller.abort();
+  const result = await pending;
+  await new Promise((resolve) => setImmediate(resolve));
+  assert.equal(result.stale, true);
+  assert.deepEqual(result.results, []);
+  assert.deepEqual(cancellations, [requests[0].requestId]);
+  registry.dispose();
+});
+
+test('terminal Provider registry scopes link supersession per buffer line', async () => {
+  const cancellations: string[] = [];
+  const resolvers: Array<(value: ReadonlyArray<NetcattyTerminalProviderResult>) => void> = [];
+  const registry = new PluginTerminalProviderRegistry({
+    async listPluginTerminalProviders() { return []; },
+    providePluginTerminal() { return new Promise((resolve) => resolvers.push(resolve)); },
+    async cancelPluginTerminalRequest(requestId) { cancellations.push(requestId); return true; },
+    async publishPluginTerminalSessionEvent() { return []; },
+  });
+  const firstLine = registry.request({
+    kind: 'terminal.link',
+    operation: 'provideLinks',
+    session,
+    supersessionKey: 'line:1',
+  });
+  const secondLine = registry.request({
+    kind: 'terminal.link',
+    operation: 'provideLinks',
+    session,
+    supersessionKey: 'line:2',
+  });
+  assert.equal(cancellations.length, 0);
+  const replacementFirstLine = registry.request({
+    kind: 'terminal.link',
+    operation: 'provideLinks',
+    session,
+    supersessionKey: 'line:1',
+  });
+  assert.equal(cancellations.length, 1);
+  resolvers[1]([]);
+  resolvers[2]([]);
+  assert.equal((await secondLine).stale, false);
+  assert.equal((await replacementFirstLine).stale, false);
+  resolvers[0]([]);
+  assert.equal((await firstLine).stale, true);
+});
+
+test('terminal Provider registry returns a stale response when a superseded bridge request rejects', async () => {
+  const resolvers: Array<{
+    resolve: (value: ReadonlyArray<NetcattyTerminalProviderResult>) => void;
+    reject: (error: Error) => void;
+  }> = [];
+  const registry = new PluginTerminalProviderRegistry({
+    async listPluginTerminalProviders() { return []; },
+    providePluginTerminal() {
+      return new Promise((resolve, reject) => resolvers.push({ resolve, reject }));
+    },
+    async cancelPluginTerminalRequest() { return true; },
+    async publishPluginTerminalSessionEvent() { return []; },
+  });
+  const first = registry.request({
+    kind: 'terminal.decoration',
+    operation: 'provideDecorations',
+    session,
+  });
+  const second = registry.request({
+    kind: 'terminal.decoration',
+    operation: 'provideDecorations',
+    session,
+  });
+  resolvers[1].resolve([]);
+  assert.equal((await second).stale, false);
+  resolvers[0].reject(new Error('cancelled'));
+  const firstResult = await first;
+  assert.equal(firstResult.stale, true);
+  assert.deepEqual(firstResult.results, []);
+});
+
+test('terminal Provider registry freezes enumeration and cancels all session requests', async () => {
+  const cancellations: string[] = [];
+  const registry = new PluginTerminalProviderRegistry({
+    async listPluginTerminalProviders() {
+      return [{
+        pluginId: 'com.example',
+        pluginVersion: '1.0.0',
+        pluginDisplayName: 'Example',
+        provider: { id: 'com.example.completion', label: 'Completion', kind: 'terminal.completion' },
+      }];
+    },
+    providePluginTerminal() { return new Promise(() => {}); },
+    async cancelPluginTerminalRequest(requestId) { cancellations.push(requestId); return true; },
+    async publishPluginTerminalSessionEvent() { return []; },
+  });
+  const providers = await registry.listProviders({ kind: 'terminal.completion' });
+  assert.equal(Object.isFrozen(providers), true);
+  assert.equal(Object.isFrozen(providers[0].provider), true);
+  void registry.request({ kind: 'terminal.completion', operation: 'provide', session });
+  void registry.request({ kind: 'terminal.decoration', operation: 'provide', session });
+  registry.cancelSession(session.sessionId);
+  await new Promise((resolve) => setImmediate(resolve));
+  assert.equal(cancellations.length, 2);
+});
+
+test('terminal Provider registry publishes metadata-only lifecycle snapshots', async () => {
+  const events: NetcattyTerminalSessionEvent[] = [];
+  const registry = new PluginTerminalProviderRegistry({
+    async listPluginTerminalProviders() { return []; },
+    async providePluginTerminal() { return []; },
+    async cancelPluginTerminalRequest() { return false; },
+    async publishPluginTerminalSessionEvent(event) { events.push(event); return []; },
+  });
+  await registry.publishSessionEvent({ type: 'connected', session });
+  await registry.publishSessionEvent({
+    type: 'cwdChanged',
+    session: { sessionId: session.sessionId, protocol: 'ssh', status: 'connected', cwd: '/srv/app' },
+  });
+  assert.deepEqual(events, [
+    { type: 'connected', session },
+    { type: 'cwdChanged', session: { ...session, cwd: '/srv/app' } },
+  ]);
+  assert.equal(Object.isFrozen(events[0]), true);
+  assert.equal(Object.isFrozen(events[0].session), true);
+});
+
+test('terminal Provider lifecycle clears optional fields instead of retaining stale metadata', async () => {
+  const events: NetcattyTerminalSessionEvent[] = [];
+  const requests: NetcattyTerminalProviderRequest[] = [];
+  const registry = new PluginTerminalProviderRegistry({
+    async listPluginTerminalProviders() { return []; },
+    async providePluginTerminal(request) { requests.push(request); return []; },
+    async cancelPluginTerminalRequest() { return false; },
+    async publishPluginTerminalSessionEvent(event) { events.push(event); return []; },
+  });
+  await registry.publishSessionEvent({
+    type: 'created',
+    session: { ...session, cwd: '/srv/app', title: 'Application' },
+  });
+  await registry.publishSessionEvent({ type: 'cwdChanged', session });
+  await registry.publishSessionEvent({ type: 'titleChanged', session });
+  await registry.request({
+    kind: 'terminal.completion',
+    operation: 'provide',
+    session,
+  });
+  assert.equal(Object.hasOwn(events[1].session, 'cwd'), false);
+  assert.equal(Object.hasOwn(events[1].session, 'title'), true);
+  assert.equal(Object.hasOwn(events[2].session, 'cwd'), false);
+  assert.equal(Object.hasOwn(events[2].session, 'title'), false);
+  assert.equal(Object.hasOwn(requests[0].session, 'cwd'), false);
+  assert.equal(Object.hasOwn(requests[0].session, 'title'), false);
+});
+
+test('terminal Provider reconnect lifecycle clears omitted connection-scoped metadata', async () => {
+  const events: NetcattyTerminalSessionEvent[] = [];
+  const requests: NetcattyTerminalProviderRequest[] = [];
+  const registry = new PluginTerminalProviderRegistry({
+    async listPluginTerminalProviders() { return []; },
+    async providePluginTerminal(request) { requests.push(request); return []; },
+    async cancelPluginTerminalRequest() { return false; },
+    async publishPluginTerminalSessionEvent(event) { events.push(event); return []; },
+  });
+  await registry.publishSessionEvent({
+    type: 'connected',
+    session: { ...session, cwd: '/srv/app', title: 'Application', alternateScreen: true },
+  });
+  await registry.publishSessionEvent({ type: 'disconnected', session: { ...session, status: 'disconnected' } });
+  await registry.publishSessionEvent({ type: 'reconnected', session });
+  await registry.request({ kind: 'terminal.completion', operation: 'provide', session });
+
+  for (const event of events.slice(1)) {
+    assert.equal(Object.hasOwn(event.session, 'cwd'), false);
+    assert.equal(Object.hasOwn(event.session, 'title'), false);
+    assert.equal(Object.hasOwn(event.session, 'alternateScreen'), false);
+  }
+  assert.equal(Object.hasOwn(requests[0].session, 'cwd'), false);
+  assert.equal(Object.hasOwn(requests[0].session, 'title'), false);
+  assert.equal(Object.hasOwn(requests[0].session, 'alternateScreen'), false);
+});
+
+test('terminal Provider requests merge the latest lifecycle snapshot before invocation', async () => {
+  const requests: NetcattyTerminalProviderRequest[] = [];
+  const registry = new PluginTerminalProviderRegistry({
+    async listPluginTerminalProviders() { return []; },
+    async providePluginTerminal(request) { requests.push(request); return []; },
+    async cancelPluginTerminalRequest() { return false; },
+    async publishPluginTerminalSessionEvent() { return []; },
+  });
+  await registry.publishSessionEvent({
+    type: 'created',
+    session: { ...session, workspaceId: 'workspace-1', title: 'Initial title', cols: 100, rows: 30 },
+  });
+  await registry.request({
+    kind: 'terminal.completion',
+    operation: 'provide',
+    session: { ...session, cwd: '/srv/app' },
+  });
+  assert.deepEqual(requests[0].session, {
+    ...session,
+    workspaceId: 'workspace-1',
+    title: 'Initial title',
+    cols: 100,
+    rows: 30,
+    cwd: '/srv/app',
+  });
+  assert.equal(Object.isFrozen(requests[0].session), true);
+});
+
+test('terminal Provider registry forwards contribution lifecycle invalidation', () => {
+  let bridgeListener: (() => void) | undefined;
+  let disposed = false;
+  const cancellations: string[] = [];
+  const registry = new PluginTerminalProviderRegistry({
+    async listPluginTerminalProviders() { return []; },
+    async providePluginTerminal() { return []; },
+    async cancelPluginTerminalRequest(requestId) { cancellations.push(requestId); return true; },
+    async publishPluginTerminalSessionEvent() { return []; },
+    onPluginContributionsChanged(listener) {
+      bridgeListener = listener;
+      return () => { disposed = true; };
+    },
+  });
+  let changes = 0;
+  const unsubscribe = registry.onDidChangeProviders(() => { changes += 1; });
+  void registry.request({ kind: 'terminal.completion', operation: 'provide', session });
+  bridgeListener?.();
+  assert.equal(changes, 1);
+  assert.equal(cancellations.length, 1);
+  unsubscribe();
+  bridgeListener?.();
+  assert.equal(changes, 1);
+  registry.dispose();
+  assert.equal(disposed, true);
+});