Multi-Agent Collaboration for Team and Friends
TypeScript agent-automationagent-orchestrationagent-workflowai-agentsai-collaborationai-memoryai-workforceautonomous-agentsclaude-codeclaude-code-skillscodexcoding-agentmulti-agentmultiple-agentone-person-businessone-person-companyone-person-teamopencodesolopreneur
import { afterEach, describe, expect, it } from "vitest"
import { readFileSync } from "node:fs"
import { getTableName } from "drizzle-orm"
import { getTableConfig } from "drizzle-orm/sqlite-core"
import { communityWriteDb } from "./helpers/community-write-db"
import * as queries from "../src/db/queries/automation"
import { automationAccessCode, automationAccessPermission } from "../src/db/automation-schema"
import { AutomationAccessCodeCreateSchema, AutomationAccessCodeUpdateSchema, automationExpiresAt, AutomationPermissionSchema, AutomationMessageSendSchema } from "../src/automation"
const databases: ReturnType<typeof communityWriteDb>[] = []
function fixture() {
const value = communityWriteDb()
value.sqlite.exec(readFileSync(new URL("../../web/migrations/0110_automation_access_code.sql", import.meta.url), "utf8"))
databases.push(value)
return value
}
afterEach(() => { for (const value of databases.splice(0)) value.sqlite.close() })
const input = () => AutomationAccessCodeCreateSchema.parse({ name: "Work", expiresIn: "24h", permissions: [{ permission: "bot.create", limit: 64, period: "hour" }, { permission: "server.create", limit: 100, period: "day" }] })
describe("Automation access codes", () => {
it("enforces fixed expiry choices, integer rates, caps and unique granted permissions", () => {
for (const data of [ { ...input(), expiresIn: "2h" }, { ...input(), permissions: [] }, { ...input(), permissions: [input().permissions[0], input().permissions[0]] }, ...[0, 1.5, 65].map((limit) => ({ ...input(), permissions: [{ permission: "bot.create", limit, period: "hour" }] })), { ...input(), permissions: [{ permission: "server.create", limit: 1537, period: "day" }] } ]) {
expect(AutomationAccessCodeCreateSchema.safeParse(data).success).toBe(false)
}
expect(AutomationAccessCodeUpdateSchema.safeParse({}).success).toBe(false)
expect(automationExpiresAt("forever")).toBeNull()
expect(automationExpiresAt("7d", 0)).toBe("1970-01-08T00:00:00.000Z")
})
it("persists a hash and independent policies, while omitting private fields from management results", async () => {
const { db, sqlite, batchSizes } = fixture()
const code = await queries.createAccessCode(db, "author", input(), "digest")
expect(await queries.listAccessCodes(db, "peer")).toEqual([])
expect(await queries.getAccessCode(db, "peer", code.id)).toBeNull()
const list = await queries.listAccessCodes(db, "author")
expect(list).toEqual([code])
expect(JSON.stringify(list)).not.toContain("digest")
expect(list[0]).not.toHaveProperty("ownerId")
expect(list[0]).not.toHaveProperty("prefix")
expect(sqlite.prepare("PRAGMA table_info(automation_access_code)").all()).not.toEqual(expect.arrayContaining([expect.objectContaining({ name: "prefix" })]))
expect(batchSizes).toEqual([[6, 8]])
expect(sqlite.prepare("SELECT secret_hash FROM automation_access_code").get()).toEqual({ secret_hash: "digest" })
expect(await queries.authenticateAccessCode(db, "digest", "server.create")).toMatchObject({ ownerId: "author", limit: 100, period: "day" })
expect(await queries.authenticateAccessCode(db, "wrong", "bot.create")).toBeNull()
})
it("lists only unexpired owned codes without deleting expired records", async () => {
const { db, sqlite } = fixture()
const now = "2026-10-30T04:00:00.000Z"
const codes = await Promise.all(["past", "boundary", "future", "permanent", "peer"].map((name) =>
queries.createAccessCode(db, name === "peer" ? "peer" : "author", { ...input(), name }, name)))
const expires = ["2026-10-30T03:59:59.999Z", now, "2026-10-30T04:00:00.001Z", null, null]
for (const [index, code] of codes.entries()) sqlite.prepare("UPDATE automation_access_code SET expires_at = ? WHERE id = ?").run(expires[index], code.id)
const listed = await queries.listAccessCodes(db, "author", now)
expect(listed.map((code) => code.name).sort()).toEqual(["future", "permanent"])
expect(listed.every((code) => code.permissions.length === 2)).toBe(true)
expect(await queries.authenticateAccessCode(db, "past", "bot.create", now)).toBeNull()
expect(await queries.authenticateAccessCode(db, "boundary", "bot.create", now)).toBeNull()
expect(await queries.getAccessCode(db, "author", codes[0].id)).toMatchObject({ name: "past" })
expect(sqlite.prepare("SELECT COUNT(*) AS count FROM automation_access_code").get()).toEqual({ count: 5 })
})
it("atomically expires only the presented active code without requiring a grant", async () => {
const { db, sqlite } = fixture()
const code = await queries.createAccessCode(db, "author", { ...input(), expiresIn: "forever" }, "self-digest")
const peer = await queries.createAccessCode(db, "peer", input(), "peer-digest")
sqlite.prepare("DELETE FROM automation_access_permission WHERE code_id = ?").run(code.id)
const now = "2026-10-30T04:00:00.000Z"
expect(await queries.expireAccessCode(db, "unknown", now)).toBe(false)
expect(await queries.expireAccessCode(db, "self-digest", now)).toBe(true)
expect(await queries.expireAccessCode(db, "self-digest", now)).toBe(false)
expect(await queries.getAccessCode(db, "author", code.id)).toMatchObject({ expiresAt: now })
expect(await queries.getAccessCode(db, "peer", peer.id)).toEqual(peer)
expect(await queries.listAccessCodes(db, "author", now)).toEqual([])
expect(await queries.authenticateAccessCode(db, "self-digest", "bot.create", now)).toBeNull()
expect(sqlite.prepare("SELECT COUNT(*) AS count FROM automation_access_code").get()).toEqual({ count: 2 })
})
it("does not self-expire codes that are expired or owned by retired humans or bots", async () => {
const { db, sqlite } = fixture()
const code = await queries.createAccessCode(db, "author", input(), "self-digest")
expect(await queries.expireAccessCode(db, "self-digest", code.expiresAt!)).toBe(false)
sqlite.prepare("UPDATE user SET deletedAt = 'deleted' WHERE id = 'author'").run()
expect(await queries.expireAccessCode(db, "self-digest")).toBe(false)
sqlite.prepare("UPDATE user SET deletedAt = NULL, isBot = 1 WHERE id = 'author'").run()
expect(await queries.expireAccessCode(db, "self-digest")).toBe(false)
expect(await queries.getAccessCode(db, "author", code.id)).toEqual(code)
})
it("scopes edits and deletion, preserves expiry on policy edits and revokes removed policies", async () => {
const { db, sqlite } = fixture()
const code = await queries.createAccessCode(db, "author", input(), "digest")
expect(await queries.updateAccessCode(db, "peer", code.id, { name: "Stolen" })).toBeNull()
expect(await queries.deleteAccessCode(db, "peer", code.id)).toBe(false)
const edited = await queries.updateAccessCode(db, "author", code.id, { permissions: [{ permission: "server.create", limit: 1, period: "day" }] })
expect(edited?.expiresAt).toBe(code.expiresAt)
expect(await queries.authenticateAccessCode(db, "digest", "bot.create")).toBeNull()
expect(await queries.authenticateAccessCode(db, "digest", "server.create")).toMatchObject({ limit: 1 })
expect((await queries.updateAccessCode(db, "author", code.id, { expiresIn: "forever" }))?.expiresAt).toBeNull()
expect(await queries.deleteAccessCode(db, "author", code.id)).toBe(true)
expect(await queries.authenticateAccessCode(db, "digest", "server.create")).toBeNull()
expect(sqlite.prepare("SELECT COUNT(*) AS count FROM automation_access_permission").get()).toEqual({ count: 0 })
})
it.each([false, true])("renames an owned code while replacing policies: %s", async (replacePolicies) => {
const { db, sqlite } = fixture()
const code = await queries.createAccessCode(db, "author", input(), "digest")
const peerCode = await queries.createAccessCode(db, "peer", input(), "peer-digest")
const permissions = replacePolicies ? [{ permission: "server.invite" as const, limit: 2, period: "day" as const }] : code.permissions
const edited = await queries.updateAccessCode(db, "author", code.id, {
name: "Renamed",
...(replacePolicies ? { permissions } : {}),
})
expect(edited).toEqual({ ...code, name: "Renamed", permissions })
expect(await queries.getAccessCode(db, "peer", peerCode.id)).toEqual(peerCode)
expect(sqlite.prepare("SELECT owner_id, secret_hash FROM automation_access_code WHERE id = ?").get(code.id))
.toEqual({ owner_id: "author", secret_hash: "digest" })
expect(await queries.authenticateAccessCode(db, "digest", "bot.create"))
.toEqual(replacePolicies ? null : expect.objectContaining({ ownerId: "author", limit: 64 }))
if (replacePolicies) {
expect(await queries.authenticateAccessCode(db, "digest", "server.invite"))
.toMatchObject({ ownerId: "author", limit: 2, period: "day" })
}
})
it("lists a code with missing policies without granting access, and leaves an empty query update unchanged", async () => {
const { db, sqlite, batchSizes } = fixture()
const code = await queries.createAccessCode(db, "author", input(), "digest")
sqlite.prepare("DELETE FROM automation_access_permission WHERE code_id = ?").run(code.id)
const withoutPolicies = { ...code, permissions: [] }
expect(await queries.listAccessCodes(db, "author")).toEqual([withoutPolicies])
expect(await queries.authenticateAccessCode(db, "digest", "bot.create")).toBeNull()
expect(await queries.updateAccessCode(db, "author", code.id, {})).toEqual(withoutPolicies)
expect(await queries.listAccessCodes(db, "author")).toEqual([withoutPolicies])
expect(batchSizes).toHaveLength(1)
})
it("keeps declared owner and policy keys aligned with the migration and cascades only the deleted owner's codes", async () => {
const { db, sqlite } = fixture()
const codeConfig = getTableConfig(automationAccessCode)
const policyConfig = getTableConfig(automationAccessPermission)
for (const config of [codeConfig, policyConfig]) {
const declared = config.foreignKeys.map((key) => {
const reference = key.reference()
return { from: reference.columns[0].name, table: getTableName(reference.foreignTable),
to: reference.foreignColumns[0].name, on_delete: key.onDelete?.toUpperCase() }
})
const migrated = (sqlite.pragma(`foreign_key_list(${config.name})`) as Array<{
from: string; table: string; to: string; on_delete: string;
}>).map(({ from, table, to, on_delete }) => ({ from, table, to, on_delete }))
expect(migrated).toEqual(declared)
}
expect(codeConfig.indexes.map(({ config }) => ({ name: config.name, columns: config.columns })))
.toEqual([{ name: "idx_automation_code_owner", columns: [automationAccessCode.ownerId] }])
expect(sqlite.pragma("index_info(idx_automation_code_owner)"))
.toEqual([expect.objectContaining({ name: "owner_id" })])
expect(policyConfig.primaryKeys[0].columns.map((column) => column.name)).toEqual(["code_id", "permission"])
expect((sqlite.pragma("table_info(automation_access_permission)") as Array<{ name: string; pk: number }>)
.filter(({ pk }) => pk > 0).map(({ name }) => name)).toEqual(["code_id", "permission"])
const authorCode = await queries.createAccessCode(db, "author", input(), "author-digest")
const peerCode = await queries.createAccessCode(db, "peer", input(), "peer-digest")
sqlite.prepare("DELETE FROM user WHERE id = ?").run("author")
expect(await queries.getAccessCode(db, "author", authorCode.id)).toBeNull()
expect(sqlite.prepare("SELECT code_id FROM automation_access_permission WHERE code_id = ?").all(authorCode.id)).toEqual([])
expect(await queries.getAccessCode(db, "peer", peerCode.id)).toEqual(peerCode)
expect(sqlite.pragma("foreign_key_check")).toEqual([])
})
it("rejects expiry at the exact boundary, soft-deleted owners and bot owners", async () => {
const { db, sqlite } = fixture()
const code = await queries.createAccessCode(db, "author", input(), "digest")
expect(await queries.authenticateAccessCode(db, "digest", "bot.create", code.expiresAt!)).toBeNull()
sqlite.prepare("UPDATE user SET deletedAt = 'deleted' WHERE id = 'author'").run()
expect(await queries.authenticateAccessCode(db, "digest", "bot.create")).toBeNull()
sqlite.prepare("UPDATE user SET deletedAt = NULL, isBot = 1 WHERE id = 'author'").run()
expect(await queries.authenticateAccessCode(db, "digest", "bot.create")).toBeNull()
})
it("scopes minimal read projections and friend resolution to the owner", async () => {
const { db, sqlite } = fixture()
sqlite.exec(`
ALTER TABLE user ADD COLUMN name TEXT NOT NULL DEFAULT '';
ALTER TABLE user ADD COLUMN discriminator TEXT NOT NULL DEFAULT '0001';
UPDATE user SET name = id;
INSERT INTO user (id,name) VALUES ('outsider','outside'), ('deleted','deleted');
INSERT INTO user (id,name,isBot,ownerUserId) VALUES ('ownbot','Helper',1,'author'), ('otherbot','Other bot',1,'peer'), ('unrelatedbot','Unrelated bot',1,'peer');
UPDATE user SET deletedAt='deleted' WHERE id='deleted';
INSERT INTO community_friendship (id,requester_id,addressee_id,status) VALUES
('accepted','author','peer','accepted'), ('otherbot','otherbot','author','accepted'), ('pending','author','outsider','pending'), ('deleted','author','deleted','accepted');
CREATE TABLE community_machine (id TEXT PRIMARY KEY,user_id TEXT,display_name TEXT,hostname TEXT,status TEXT,available_runtimes TEXT NOT NULL DEFAULT '[]');
INSERT INTO community_machine (id,user_id,display_name,hostname,status) VALUES ('mac1','author','My Mac','hidden-host','online'),('mac0','author','Stopped Mac','hidden-host','offline'),('other','peer','Other','secret-host','online');
`)
sqlite.prepare("UPDATE community_machine SET available_runtimes = ? WHERE id = ?").run(JSON.stringify(["codex"]), "mac1")
expect(await queries.listMachines(db, "author")).toEqual([{ id: "mac0", name: "Stopped Mac", status: "offline", availableRuntimes: [] }, { id: "mac1", name: "My Mac", status: "online", availableRuntimes: ["codex"] }])
expect(await queries.listFriends(db, "author")).toEqual([
{ name: "Helper", discriminator: "0001", isBot: true, ownerUserId: "author" },
{ name: "Other bot", discriminator: "0001", isBot: true, ownerUserId: "peer" },
{ name: "peer", discriminator: "0001", isBot: false, ownerUserId: null },
])
expect(await queries.getFriendByHandle(db, "author", "outside#0001")).toBeNull()
for (const handle of ["", "peer", "peer#123", "peer#abcd", " #0001"]) {
expect(await queries.getFriendByHandle(db, "author", handle)).toBeNull()
}
expect(await queries.getFriendByHandle(db, "author", "peer#0001")).toMatchObject({ id: "peer" })
expect(await queries.getFriendByHandle(db, "author", "Helper#0001")).toMatchObject({ id: "ownbot" })
})
})
it("supports seven independent grants and scopes bot identity resolution in SQL", async () => {
const all = AutomationAccessCodeCreateSchema.parse({ name: "all", permissions: AutomationPermissionSchema.options.map((permission) => ({ permission, limit: 1, period: "hour" })) })
expect(all.permissions).toHaveLength(7)
const { db, sqlite } = fixture()
const code = await queries.createAccessCode(db, "author", all, "send-digest")
expect(await queries.authenticateAccessCode(db, "send-digest", "message.send")).toMatchObject({ ownerId: "author", permission: "message.send" })
expect(code.permissions).toHaveLength(7)
sqlite.exec(`ALTER TABLE user ADD COLUMN name TEXT NOT NULL DEFAULT ''; ALTER TABLE user ADD COLUMN discriminator TEXT NOT NULL DEFAULT '0001';
INSERT INTO user (id,name,isBot,ownerUserId) VALUES ('ownbot','Helper',1,'author'), ('otherbot','Other',1,'peer'), ('deletedbot','Deleted',1,'author');
UPDATE user SET deletedAt='deleted' WHERE id='deletedbot'; UPDATE user SET name=id WHERE id IN ('author','peer');`)
expect(await queries.getOwnedBotByHandle(db, "author", "Helper#0001")).toEqual({ id: "ownbot" })
for (const handle of ["Other#0001", "Deleted#0001", "author#0001", "peer#0001", "Helper", "@Helper#0001"]) {
expect(await queries.getOwnedBotByHandle(db, "author", handle)).toBeNull()
}
expect(await queries.getOwnedBotByHandle(db, "peer", "Helper#0001")).toBeNull()
})
it("validates file-send requests without accepting extra authority fields", () => {
const body = { target: "/.dm/Alice#0001", as: "me", content: "hello\n", nonce: "n" }
expect(AutomationMessageSendSchema.parse(body)).toEqual(body)
expect(AutomationMessageSendSchema.parse({ ...body, as: "@Helper#0001" }).as).toBe("@Helper#0001")
for (const change of [{ as: "Helper#0001" }, { as: "@Helper" }, { content: " " }, { target: "id" }, { ownerId: "peer" }, { nonce: "" }]) {
expect(AutomationMessageSendSchema.safeParse({ ...body, ...change }).success).toBe(false)
}
})