agl 1.0.17 → 21.0.2

package/ts_migration/v6_protocoldocumentmigration.ts

@@ -0,0 +1,144 @@
+import * as plugins from '../ts/plugins.js';
+import {
+  assertControllerSessionGroupsDocument,
+  assertControllerSettingsDocument,
+  ControllerSessionGroupsModel,
+  ControllerSettingsModel,
+} from '../ts/classes.authmodels.js';
+import { AuthError } from '../ts/interfaces.auth.js';
+import type {
+  IControllerSessionGroupsDocument,
+  IControllerSettingsDocument,
+} from '../ts/interfaces.projects.js';
+import {
+  migrateProtocolV6SessionGroupsDocument,
+  migrateProtocolV6SettingsDocument,
+} from './v6_protocoldocuments.js';
+
+const migrationPageLimit = 128;
+
+const persistedBodyFromRawDocument = (
+  valueArg: Record<string, unknown>,
+): Record<string, unknown> => {
+  const body = { ...valueArg };
+  delete body._id;
+  delete body._smartdataRevision;
+  return body;
+};
+
+export class ProtocolV6DocumentMigration {
+  constructor(private readonly database: plugins.smartdata.SmartdataDb | undefined) {}
+
+  /** Runs before store readiness and is safe to repeat after partial or concurrent completion. */
+  public async run(): Promise<void> {
+    if (!this.database) {
+      throw new AuthError('not_initialized', 'The authentication store database is unavailable.');
+    }
+
+    const settingsCollection = ControllerSettingsModel.collection.mongoDbCollection;
+    let lastSettingsId: plugins.smartdata.TStoredDocument<IControllerSettingsDocument>['_id']
+      | undefined;
+    while (true) {
+      const cursor = settingsCollection.find(
+        lastSettingsId ? { _id: { $gt: lastSettingsId } } : {},
+      ).sort({ _id: 1 }).limit(migrationPageLimit);
+      let settingsDocuments: Awaited<ReturnType<typeof cursor.toArray>>;
+      try {
+        settingsDocuments = await cursor.toArray();
+      } finally {
+        await cursor.close();
+      }
+      for (const rawDocument of settingsDocuments) {
+        const migration = migrateProtocolV6SettingsDocument(
+          persistedBodyFromRawDocument(rawDocument),
+        );
+        assertControllerSettingsDocument(migration.document);
+        if (!migration.migrated) continue;
+        const revision = plugins.crypto.randomUUID();
+        const selector = rawDocument._smartdataRevision === undefined
+          ? { _id: rawDocument._id, _smartdataRevision: { $exists: false } }
+          : { _id: rawDocument._id, _smartdataRevision: rawDocument._smartdataRevision };
+        const replaced = await settingsCollection.findOneAndReplace(
+          selector,
+          { _id: rawDocument._id, ...migration.document, _smartdataRevision: revision },
+          { returnDocument: 'after', includeResultMetadata: false, upsert: false },
+        );
+        if (!replaced) {
+          const concurrent = await settingsCollection.findOne({ _id: rawDocument._id });
+          if (!concurrent) {
+            throw new AuthError(
+              'concurrent_change',
+              'The settings protocol migration changed concurrently.',
+            );
+          }
+          const concurrentMigration = migrateProtocolV6SettingsDocument(
+            persistedBodyFromRawDocument(concurrent),
+          );
+          assertControllerSettingsDocument(concurrentMigration.document);
+          if (concurrentMigration.migrated) {
+            throw new AuthError(
+              'concurrent_change',
+              'The settings protocol migration changed concurrently.',
+            );
+          }
+        }
+      }
+      const lastDocument = settingsDocuments.at(-1);
+      if (!lastDocument || settingsDocuments.length < migrationPageLimit) break;
+      lastSettingsId = lastDocument._id;
+    }
+
+    const layoutsCollection = ControllerSessionGroupsModel.collection.mongoDbCollection;
+    let lastLayoutId: plugins.smartdata.TStoredDocument<IControllerSessionGroupsDocument>['_id']
+      | undefined;
+    while (true) {
+      const cursor = layoutsCollection.find(
+        lastLayoutId ? { _id: { $gt: lastLayoutId } } : {},
+      ).sort({ _id: 1 }).limit(migrationPageLimit);
+      let layoutDocuments: Awaited<ReturnType<typeof cursor.toArray>>;
+      try {
+        layoutDocuments = await cursor.toArray();
+      } finally {
+        await cursor.close();
+      }
+      for (const rawDocument of layoutDocuments) {
+        const migration = migrateProtocolV6SessionGroupsDocument(
+          persistedBodyFromRawDocument(rawDocument),
+        );
+        assertControllerSessionGroupsDocument(migration.document);
+        if (!migration.migrated) continue;
+        const revision = plugins.crypto.randomUUID();
+        const selector = rawDocument._smartdataRevision === undefined
+          ? { _id: rawDocument._id, _smartdataRevision: { $exists: false } }
+          : { _id: rawDocument._id, _smartdataRevision: rawDocument._smartdataRevision };
+        const replaced = await layoutsCollection.findOneAndReplace(
+          selector,
+          { _id: rawDocument._id, ...migration.document, _smartdataRevision: revision },
+          { returnDocument: 'after', includeResultMetadata: false, upsert: false },
+        );
+        if (!replaced) {
+          const concurrent = await layoutsCollection.findOne({ _id: rawDocument._id });
+          if (!concurrent) {
+            throw new AuthError(
+              'concurrent_change',
+              'The session layout protocol migration changed concurrently.',
+            );
+          }
+          const concurrentMigration = migrateProtocolV6SessionGroupsDocument(
+            persistedBodyFromRawDocument(concurrent),
+          );
+          assertControllerSessionGroupsDocument(concurrentMigration.document);
+          if (concurrentMigration.migrated) {
+            throw new AuthError(
+              'concurrent_change',
+              'The session layout protocol migration changed concurrently.',
+            );
+          }
+        }
+      }
+      const lastDocument = layoutDocuments.at(-1);
+      if (!lastDocument || layoutDocuments.length < migrationPageLimit) break;
+      lastLayoutId = lastDocument._id;
+    }
+  }
+}

package/ts_migration/v6_protocoldocuments.ts

@@ -0,0 +1,198 @@
+import type {
+  TControllerModelChoice,
+  IControllerRuntimeId,
+  IControllerSessionGroup,
+  TControllerSessionId,
+} from '../ts_interfaces/index.js';
+import type {
+  IControllerSessionGroupsDocument,
+  IControllerSettingsDocument,
+} from '../ts/interfaces.projects.js';
+
+type TObject = Record<string, unknown>;
+
+export interface IProtocolV6DocumentMigrationResult<T> {
+  document: T;
+  migrated: boolean;
+}
+
+const isPlainObject = (valueArg: unknown): valueArg is TObject => {
+  if (typeof valueArg !== 'object' || valueArg === null || Array.isArray(valueArg)) return false;
+  const prototype = Object.getPrototypeOf(valueArg);
+  return prototype === Object.prototype || prototype === null;
+};
+
+const hasExactKeys = (
+  valueArg: TObject,
+  requiredArg: readonly string[],
+  optionalArg: readonly string[] = [],
+): boolean => {
+  const allowed = new Set([...requiredArg, ...optionalArg]);
+  return requiredArg.every((key) => Object.hasOwn(valueArg, key))
+    && Object.keys(valueArg).every((key) => allowed.has(key));
+};
+
+const isBoundedString = (valueArg: unknown, maximumBytesArg: number): valueArg is string =>
+  typeof valueArg === 'string'
+  && valueArg.length > 0
+  && Buffer.byteLength(valueArg, 'utf8') <= maximumBytesArg;
+
+const isRuntimeId = (valueArg: unknown): valueArg is IControllerRuntimeId =>
+  isPlainObject(valueArg)
+  && hasExactKeys(valueArg, ['harnessId', 'nativeId'])
+  && (
+    valueArg.harnessId === 'opencode'
+    || valueArg.harnessId === 'flex'
+    || valueArg.harnessId === 'controller'
+  )
+  && isBoundedString(valueArg.nativeId, 512);
+
+const qualifyLegacySessionId = (nativeIdArg: string): TControllerSessionId => ({
+  harnessId: 'opencode',
+  nativeId: nativeIdArg,
+});
+
+const toSessionRuntimeId = (valueArg: IControllerRuntimeId): TControllerSessionId | undefined => (
+  valueArg.harnessId === 'opencode' || valueArg.harnessId === 'flex'
+    ? valueArg as TControllerSessionId
+    : undefined
+);
+
+const isLegacySessionId = (valueArg: unknown): valueArg is string =>
+  isBoundedString(valueArg, 512) && /^[A-Za-z0-9_-]+$/.test(valueArg);
+
+const isLegacyModelChoice = (valueArg: unknown): valueArg is {
+  providerID: string;
+  modelID: string;
+  variant?: string;
+} => {
+  if (!isPlainObject(valueArg)) return false;
+  if (!hasExactKeys(valueArg, ['providerID', 'modelID'], ['variant'])) return false;
+  return isBoundedString(valueArg.providerID, 256)
+    && isBoundedString(valueArg.modelID, 256)
+    && (
+      !Object.hasOwn(valueArg, 'variant')
+      || (
+        typeof valueArg.variant === 'string'
+        && /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/.test(valueArg.variant)
+      )
+    );
+};
+
+const qualifyLegacyModel = (
+  modelArg: { providerID: string; modelID: string; variant?: string },
+): TControllerModelChoice => ({
+  harnessId: 'opencode',
+  providerID: modelArg.providerID,
+  modelID: modelArg.modelID,
+  ...(modelArg.variant === undefined ? {} : { variant: modelArg.variant }),
+});
+
+export const migrateProtocolV6SettingsDocument = (
+  valueArg: unknown,
+): IProtocolV6DocumentMigrationResult<IControllerSettingsDocument> => {
+  if (!isPlainObject(valueArg)) throw new Error('Invalid controller settings migration document.');
+  if (hasExactKeys(valueArg, ['id', 'controllerId', 'defaultModels'], ['autoAcceptPermissions'])) {
+    return {
+      document: valueArg as unknown as IControllerSettingsDocument,
+      migrated: false,
+    };
+  }
+  if (
+    !hasExactKeys(valueArg, ['id', 'controllerId', 'defaultModel'], ['autoAcceptPermissions'])
+    || (valueArg.defaultModel !== null && !isLegacyModelChoice(valueArg.defaultModel))
+  ) {
+    throw new Error('Invalid legacy controller settings migration document.');
+  }
+  return {
+    document: {
+      id: valueArg.id as string,
+      controllerId: valueArg.controllerId as string,
+      defaultModels: valueArg.defaultModel === null
+        ? []
+        : [qualifyLegacyModel(valueArg.defaultModel)],
+      ...(valueArg.autoAcceptPermissions === undefined
+        ? {}
+        : { autoAcceptPermissions: valueArg.autoAcceptPermissions as true }),
+    },
+    migrated: true,
+  };
+};
+
+export const migrateProtocolV6SessionGroupsDocument = (
+  valueArg: unknown,
+): IProtocolV6DocumentMigrationResult<IControllerSessionGroupsDocument> => {
+  if (!isPlainObject(valueArg)) throw new Error('Invalid controller layout migration document.');
+  if (
+    !hasExactKeys(
+      valueArg,
+      ['id', 'controllerId', 'projectId', 'groups'],
+      ['ungroupedSessionIds', 'revision'],
+    )
+    || !Array.isArray(valueArg.groups)
+  ) {
+    throw new Error('Invalid controller layout migration document.');
+  }
+  const hasLegacyShape = valueArg.ungroupedSessionIds === undefined
+    || valueArg.revision === undefined
+    || valueArg.groups.some((groupArg) => (
+      isPlainObject(groupArg)
+      && Array.isArray(groupArg.sessionIds)
+      && groupArg.sessionIds.some(isLegacySessionId)
+    ))
+    || (
+      Array.isArray(valueArg.ungroupedSessionIds)
+      && valueArg.ungroupedSessionIds.some(isLegacySessionId)
+    );
+  if (!hasLegacyShape) {
+    return {
+      document: valueArg as unknown as IControllerSessionGroupsDocument,
+      migrated: false,
+    };
+  }
+
+  const groups: IControllerSessionGroup[] = valueArg.groups.map((groupArg) => {
+    if (
+      !isPlainObject(groupArg)
+      || !hasExactKeys(groupArg, ['id', 'name', 'sessionIds'])
+      || !Array.isArray(groupArg.sessionIds)
+    ) {
+      throw new Error('Invalid legacy controller layout group.');
+    }
+    return {
+      id: groupArg.id as string,
+      name: groupArg.name as string,
+      sessionIds: groupArg.sessionIds.flatMap((sessionIdArg): TControllerSessionId[] => {
+        if (isLegacySessionId(sessionIdArg)) return [qualifyLegacySessionId(sessionIdArg)];
+        if (isRuntimeId(sessionIdArg)) {
+          const sessionId = toSessionRuntimeId(sessionIdArg);
+          return sessionId ? [sessionId] : [];
+        }
+        throw new Error('Invalid legacy controller layout session ID.');
+      }),
+    };
+  });
+  const legacyUngrouped = valueArg.ungroupedSessionIds ?? [];
+  if (!Array.isArray(legacyUngrouped)) {
+    throw new Error('Invalid legacy controller ungrouped session list.');
+  }
+  const ungroupedSessionIds = legacyUngrouped.flatMap((sessionIdArg): TControllerSessionId[] => {
+    if (isLegacySessionId(sessionIdArg)) return [qualifyLegacySessionId(sessionIdArg)];
+    if (isRuntimeId(sessionIdArg)) {
+      const sessionId = toSessionRuntimeId(sessionIdArg);
+      return sessionId ? [sessionId] : [];
+    }
+    throw new Error('Invalid legacy controller ungrouped session ID.');
+  });
+  return {
+    document: {
+      id: valueArg.id as string,
+      controllerId: valueArg.controllerId as string,
+      projectId: valueArg.projectId as string,
+      groups,
+      ungroupedSessionIds,
+      revision: valueArg.revision === undefined ? 0 : valueArg.revision as number,
+    },
+    migrated: true,
+  };
+};

package/ts_web/00_commitinfo_data.ts

@@ -0,0 +1,8 @@
+/**
+ * autocreated commitinfo by @push.rocks/commitinfo
+ */
+export const commitinfo = {
+  name: 'agl',
+  version: '21.0.2',
+  description: 'Agent Gateway Layer for OpenCode and FlexHarness sessions'
+}