@frockbot/configuration-core 0.0.0 → 0.1.0

package/package.json

@@ -1,14 +1,30 @@
 {
   "name": "@frockbot/configuration-core",
-  "version": "0.0.0",
-  "description": "Placeholder reserving this name for trusted publishing. Superseded by the first release.",
-  "license": "UNLICENSED",
+  "version": "0.1.0",
+  "private": false,
+  "type": "module",
+  "exports": {
+    ".": "./src/index.ts",
+    "./bot-id": "./src/bot-id.ts"
+  },
+  "scripts": {
+    "test": "bun test src",
+    "typecheck": "tsc --noEmit -p tsconfig.json"
+  },
+  "dependencies": {
+    "@frockbot/connection-core": "0.1.0",
+    "@frockbot/kernel-composition": "0.1.0"
+  },
+  "devDependencies": {
+    "@types/bun": "1.3.6",
+    "typescript": "^7.0.2"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/timoconnellaus/frockbot.git",
     "directory": "packages/configuration-core"
-  },
-  "publishConfig": {
-    "access": "public"
   }
 }

package/src/bot-id.ts

@@ -0,0 +1,5 @@
+import { isPublicIdentifier } from "./identifiers.js";
+
+export function isBotIdV1(value: unknown): value is string {
+  return isPublicIdentifier(value);
+}

package/src/bot-identity.test.ts

@@ -0,0 +1,186 @@
+// Bot identity: the title, the name's provenance, and the sidebar-hidden flag.
+//
+// The first test is the one that matters most: a Bot settings record written
+// before any of this existed must still decode, because widening a durable DTO
+// with optional fields is the only migration this project permits.
+import { describe, expect, test } from "bun:test";
+import {
+  applyBotProfilePatchV1,
+  decodeBotSettingsViewV1,
+  decodeConfigurationCommandV1,
+  type BotProfile,
+} from "./index.js";
+
+function settings(profile: Record<string, unknown>): Record<string, unknown> {
+  return {
+    schemaVersion: 1,
+    botId: "primary",
+    revision: 2,
+    profile,
+    notifications: { enabled: false },
+    assignments: [],
+    assignmentOperations: [],
+  };
+}
+
+describe("Bot identity codecs", () => {
+  test("decodes a Bot settings record written before identity was widened", () => {
+    const decoded = decodeBotSettingsViewV1(
+      settings({ name: "Housework", description: "Keeps things tidy." }),
+    );
+    expect(decoded.profile).toEqual({
+      name: "Housework",
+      description: "Keeps things tidy.",
+    });
+    expect(decoded.profile.title).toBeUndefined();
+    expect(decoded.profile.namedBy).toBeUndefined();
+    expect(decoded.profile.hiddenFromSidebar).toBeUndefined();
+  });
+
+  test("round-trips a title, provenance, and the hidden flag", () => {
+    const profile = {
+      name: "Housework",
+      title: "Chief of staff",
+      namedBy: "bot" as const,
+      hiddenFromSidebar: true,
+    };
+    expect(decodeBotSettingsViewV1(settings(profile)).profile).toEqual(profile);
+  });
+
+  test("refuses a profile field outside the declared vocabulary", () => {
+    expect(() =>
+      decodeBotSettingsViewV1(settings({ name: "Housework", nickname: "H" })),
+    ).toThrow("profile has invalid fields");
+    expect(() =>
+      decodeBotSettingsViewV1(
+        settings({ name: "Housework", namedBy: "admin" }),
+      ),
+    ).toThrow("profile.namedBy is invalid");
+    expect(() =>
+      decodeBotSettingsViewV1(
+        settings({ name: "Housework", hiddenFromSidebar: "yes" }),
+      ),
+    ).toThrow("profile.hiddenFromSidebar must be a boolean");
+  });
+});
+
+describe("bot/set-profile", () => {
+  test("decodes a partial update carrying only the fields it changes", () => {
+    expect(
+      decodeConfigurationCommandV1({
+        schemaVersion: 1,
+        type: "bot/set-profile",
+        commandId: "command-1",
+        botId: "primary",
+        expectedRevision: 3,
+        namedBy: "bot",
+        profile: { name: "Atlas" },
+      }),
+    ).toEqual({
+      schemaVersion: 1,
+      type: "bot/set-profile",
+      commandId: "command-1",
+      botId: "primary",
+      expectedRevision: 3,
+      namedBy: "bot",
+      profile: { name: "Atlas" },
+    });
+  });
+
+  test("carries the Bot writer, and refuses one aimed at another Bot", () => {
+    const command = {
+      schemaVersion: 1,
+      type: "bot/set-profile",
+      commandId: "command-1",
+      botId: "primary",
+      expectedRevision: 3,
+      namedBy: "bot",
+      profile: { name: "Atlas" },
+    } as const;
+    const writer = {
+      kind: "bot",
+      botId: "primary",
+      sessionId: "user-1:primary",
+      turnId: "turn-4",
+    } as const;
+    expect(decodeConfigurationCommandV1({ ...command, writer })).toEqual({
+      ...command,
+      writer,
+    });
+    // A Bot writes only its own profile, so the writer must name the target.
+    expect(() =>
+      decodeConfigurationCommandV1({
+        ...command,
+        writer: { ...writer, botId: "other" },
+      }),
+    ).toThrow("writer.botId is invalid");
+    expect(() =>
+      decodeConfigurationCommandV1({
+        ...command,
+        writer: { ...writer, kind: "user" },
+      }),
+    ).toThrow("writer.kind is invalid");
+    expect(() =>
+      decodeConfigurationCommandV1({
+        ...command,
+        writer: { ...writer, runId: "run-1" },
+      }),
+    ).toThrow("writer has invalid fields");
+  });
+
+  test("refuses an empty patch and an unknown patch field", () => {
+    const command = {
+      schemaVersion: 1,
+      type: "bot/set-profile",
+      commandId: "command-1",
+      botId: "primary",
+      expectedRevision: 3,
+    };
+    expect(() =>
+      decodeConfigurationCommandV1({ ...command, profile: {} }),
+    ).toThrow("profile has invalid fields");
+    expect(() =>
+      decodeConfigurationCommandV1({ ...command, profile: { namedBy: "bot" } }),
+    ).toThrow("profile has invalid fields");
+  });
+
+  test("changes only the fields the patch carries", () => {
+    const current: BotProfile = {
+      name: "Housework",
+      title: "Chief of staff",
+      description: "Keeps things tidy.",
+      hiddenFromSidebar: true,
+    };
+    expect(
+      applyBotProfilePatchV1(current, { title: "Night shift" }, "user"),
+    ).toEqual({ ...current, title: "Night shift" });
+  });
+
+  test("records the writer only when the name actually changes", () => {
+    const current: BotProfile = { name: "Housework", namedBy: "user" };
+    expect(
+      applyBotProfilePatchV1(current, { name: "Atlas" }, "bot").namedBy,
+    ).toBe("bot");
+    expect(
+      applyBotProfilePatchV1(current, { name: "Housework" }, "bot").namedBy,
+    ).toBe("user");
+    expect(
+      applyBotProfilePatchV1(current, { title: "Chief" }, "bot").namedBy,
+    ).toBe("user");
+  });
+
+  test("clears optional fields with empty values", () => {
+    const current: BotProfile = {
+      name: "Housework",
+      title: "Chief of staff",
+      hiddenFromSidebar: true,
+    };
+    expect(
+      applyBotProfilePatchV1(
+        current,
+        { title: "", hiddenFromSidebar: false },
+        "user",
+      ),
+    ).toEqual({ name: "Housework" });
+  });
+});

package/src/errors.ts

@@ -0,0 +1,18 @@
+/**
+ * The refusal every configuration seam raises when an inbound value is not
+ * what its contract declares.
+ *
+ * It lives in its own module so a decoder that is *not* the main configuration
+ * codec — `./package-settings.ts`, which validates a value against the schema
+ * its Package declared — can raise the same refusal without importing the
+ * module that re-exports it.
+ *
+ * The name is load-bearing: it crosses the Durable Object RPC boundary, where
+ * the class does not, and the gateway maps it to 400 by name.
+ */
+export class ConfigurationDecodeError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = "ConfigurationDecodeError";
+  }
+}

package/src/identifiers.ts

@@ -0,0 +1,40 @@
+const PUBLIC_IDENTIFIER_PATTERN = /^[a-zA-Z0-9][a-zA-Z0-9._-]{0,127}$/;
+const RPC_IDENTIFIER_PATTERN = /^[a-zA-Z0-9][a-zA-Z0-9._:@-]{0,127}$/;
+const APPLICATION_DEPLOYMENT_HASH_PATTERN =
+  /^[a-zA-Z0-9][a-zA-Z0-9._:-]{0,255}$/;
+
+const RESERVED_CONNECTION_IDENTIFIERS = new Set([
+  "__defineGetter__",
+  "__defineSetter__",
+  "__lookupGetter__",
+  "__lookupSetter__",
+  "__proto__",
+  "constructor",
+  "hasOwnProperty",
+  "isPrototypeOf",
+  "propertyIsEnumerable",
+  "prototype",
+  "toLocaleString",
+  "toString",
+  "valueOf",
+]);
+
+export function isPublicIdentifier(value: unknown): value is string {
+  return typeof value === "string" && PUBLIC_IDENTIFIER_PATTERN.test(value);
+}
+
+export function isRpcIdentifier(value: unknown): value is string {
+  return typeof value === "string" && RPC_IDENTIFIER_PATTERN.test(value);
+}
+
+export function isApplicationDeploymentHash(value: unknown): value is string {
+  return (
+    typeof value === "string" && APPLICATION_DEPLOYMENT_HASH_PATTERN.test(value)
+  );
+}
+
+export function isConnectionIdentifier(value: unknown): value is string {
+  return (
+    isPublicIdentifier(value) && !RESERVED_CONNECTION_IDENTIFIERS.has(value)
+  );
+}