@kevin5251984/guild 0.2.12

package/src/plugins/api.ts

@@ -0,0 +1,8 @@
+import type { Context } from "cordis";
+
+function apply(ctx: Context) {
+  void ctx.server.listen();
+}
+Object.assign(apply, { inject: ["server", "store", "chat", "llm", "harness"] });
+
+export default apply;

package/src/plugins/chat.ts

@@ -0,0 +1,31 @@
+import { Service, type Context } from "cordis";
+import {
+  chatReply,
+  generateMarkdown,
+  type ChatReply,
+  type GenerateKind,
+  type GeneratedMarkdown,
+} from "../generate.ts";
+
+export class ChatService extends Service {
+  static inject = ["store", "llm", "harness"];
+
+  constructor(ctx: Context) {
+    super(ctx, "chat");
+  }
+
+  reply(input: Parameters<typeof chatReply>[0]): Promise<ChatReply> {
+    return this.ctx.harness.turn(input);
+  }
+
+  generate(kind: GenerateKind, prompt: string): Promise<GeneratedMarkdown> {
+    return generateMarkdown(
+      kind,
+      prompt,
+      this.ctx.store.env,
+      this.ctx.store.dataDir,
+    );
+  }
+}
+
+export default ChatService;

package/src/plugins/harness.ts

@@ -0,0 +1,77 @@
+import { Service, type Context } from "cordis";
+import { chatReply, type ChatReply } from "../generate.ts";
+import { guildEnvOf } from "../start.ts";
+import {
+  policyFor,
+  runAgentLoop,
+  type HarnessPolicy,
+  type Sandbox,
+} from "../harness.ts";
+import type { ToolContext, ToolOutcome } from "../tools.ts";
+
+export type HarnessConfig = {
+  sandbox?: Sandbox;
+  workspace?: string;
+};
+
+export class HarnessService extends Service {
+  static inject = ["store", "tools"];
+  private readonly config: HarnessConfig;
+
+  constructor(ctx: Context, config: HarnessConfig = {}) {
+    super(ctx, "harness");
+    this.config = config;
+  }
+
+  policy(position?: string): HarnessPolicy {
+    return policyFor(guildEnvOf(this.ctx), {
+      sandbox: this.config.sandbox,
+      workspace: this.config.workspace,
+      position,
+    });
+  }
+
+  sandbox(position?: string): Sandbox {
+    return this.policy(position).sandbox;
+  }
+
+  workspace(): string {
+    return this.policy().workspace;
+  }
+
+  dispatch(
+    name: string,
+    args: Record<string, unknown>,
+    toolCtx: ToolContext,
+  ): Promise<ToolOutcome> {
+    return this.ctx.tools.execute(name, args, toolCtx);
+  }
+
+  loop = runAgentLoop;
+
+  async turn(
+    input: Parameters<typeof chatReply>[0],
+  ): Promise<ChatReply> {
+    const policy = policyFor(guildEnvOf(this.ctx), {
+      sandbox: input.sandbox ?? this.config.sandbox,
+      workspace: input.workspace ?? this.config.workspace,
+      position: input.position,
+    });
+    const mcp = this.ctx.get("mcp");
+    const mcpTools =
+      input.mcpTools !== undefined
+        ? input.mcpTools
+        : mcp
+          ? await mcp.toolRefs()
+          : [];
+    return chatReply({
+      ...input,
+      sandbox: policy.sandbox,
+      workspace: policy.workspace,
+      mcpTools,
+      dispatch: (name, args, toolCtx) => this.dispatch(name, args, toolCtx),
+    });
+  }
+}
+
+export default HarnessService;

package/src/plugins/llm.ts

@@ -0,0 +1,50 @@
+import { Service, type Context } from "cordis";
+import type { AuxRole, ModelRef, ModelsFile } from "@guild/protocol";
+import {
+  llmComplete,
+  mergeModelsFile,
+  publicModels,
+  readModelsFile,
+  resolveLlm,
+} from "../llm.ts";
+
+export class LlmService extends Service {
+  static inject = ["store"];
+
+  constructor(ctx: Context) {
+    super(ctx, "llm");
+  }
+
+  readModels(): ModelsFile {
+    return readModelsFile(this.ctx.store.dataDir);
+  }
+
+  mergeModels(patch: Partial<ModelsFile>): ModelsFile {
+    return mergeModelsFile(this.ctx.store.dataDir, patch);
+  }
+
+  publicModels(env: NodeJS.ProcessEnv = this.ctx.store.env) {
+    return publicModels(this.ctx.store.dataDir, env);
+  }
+
+  resolve(
+    env: NodeJS.ProcessEnv = this.ctx.store.env,
+    role?: AuxRole | "chat",
+    prefer?: ModelRef | null,
+  ) {
+    return resolveLlm(this.ctx.store.dataDir, env, role, prefer);
+  }
+
+  complete(
+    input: Omit<Parameters<typeof llmComplete>[0], "dataDir"> & {
+      dataDir?: string;
+    },
+  ) {
+    return llmComplete({
+      ...input,
+      dataDir: input.dataDir ?? this.ctx.store.dataDir,
+    });
+  }
+}
+
+export default LlmService;

package/src/plugins/mcp.ts

@@ -0,0 +1,58 @@
+import { Service, type Context } from "cordis";
+import {
+  callMcpTool,
+  importHostMcp,
+  listGuildMcp,
+  listHostMcp,
+  listMcpToolRefs,
+  removeGuildMcp,
+  upsertGuildMcp,
+  type McpLaunch,
+} from "../mcp.ts";
+
+export class McpService extends Service {
+  static inject = ["store", "tools"];
+
+  constructor(ctx: Context) {
+    super(ctx, "mcp");
+    ctx.tools.registerPrefix("mcp__", (name, args, toolCtx) => {
+      const dataDir = toolCtx.dataDir ?? this.dataDir;
+      if (!dataDir) return { text: "mcp needs a dataDir", isError: true };
+      return callMcpTool(dataDir, name, args, toolCtx.mcpTools ?? []);
+    });
+  }
+
+  get dataDir(): string {
+    return this.ctx.store.dataDir;
+  }
+
+  list() {
+    return listGuildMcp(this.dataDir);
+  }
+
+  listHost() {
+    return listHostMcp();
+  }
+
+  upsert(name: string, launch: McpLaunch) {
+    return upsertGuildMcp(this.dataDir, name, launch);
+  }
+
+  importHost(hostId: string) {
+    return importHostMcp(this.dataDir, hostId);
+  }
+
+  remove(name: string) {
+    return removeGuildMcp(this.dataDir, name);
+  }
+
+  toolRefs() {
+    return listMcpToolRefs(this.dataDir);
+  }
+
+  call(name: string, args: Record<string, unknown>) {
+    return callMcpTool(this.dataDir, name, args);
+  }
+}
+
+export default McpService;

package/src/plugins/memory.ts

@@ -0,0 +1,42 @@
+import { Service, type Context } from "cordis";
+import { harvestBotMemory, harvestChannelMemory } from "../memory.ts";
+
+export class MemoryService extends Service {
+  static inject = ["store", "llm"];
+
+  constructor(ctx: Context) {
+    super(ctx, "memory");
+    ctx.on("guild/turn-complete", (turn) => {
+      const store = ctx.store.guild;
+      const env = ctx.store.env;
+      const prefer = store.getBot(turn.botId)?.model ?? null;
+      void harvestBotMemory({
+        store,
+        botId: turn.botId,
+        userMessage: turn.userText,
+        reply: turn.reply,
+        env,
+        prefer,
+      }).catch(() => {});
+      const room = store.getRoom(turn.roomId);
+      if (room?.kind === "channel") {
+        void harvestChannelMemory({
+          store,
+          roomId: turn.roomId,
+          userMessage: turn.userText,
+          replies: [
+            {
+              handle: store.getBot(turn.botId)?.handle,
+              author: turn.botId,
+              body: turn.reply,
+            },
+          ],
+          env,
+          prefer,
+        }).catch(() => {});
+      }
+    });
+  }
+}
+
+export default MemoryService;

package/src/plugins/oauth.ts

@@ -0,0 +1,47 @@
+import { Service, type Context } from "cordis";
+import {
+  completeLogin,
+  listSubscriptions,
+  logoutOAuth,
+  pollLogin,
+  startLogin,
+  storedAccessToken,
+} from "../oauth.ts";
+
+export class OAuthService extends Service {
+  static inject = ["store"];
+
+  constructor(ctx: Context) {
+    super(ctx, "oauth");
+  }
+
+  get dataDir(): string {
+    return this.ctx.store.dataDir;
+  }
+
+  list() {
+    return listSubscriptions(this.dataDir);
+  }
+
+  start(id: string) {
+    return startLogin(this.dataDir, id);
+  }
+
+  poll(id: string) {
+    return pollLogin(this.dataDir, id);
+  }
+
+  complete(id: string, input: { code?: string; url?: string }) {
+    return completeLogin(this.dataDir, id, input);
+  }
+
+  logout(id: string) {
+    return logoutOAuth(this.dataDir, id);
+  }
+
+  token(id: string) {
+    return storedAccessToken(this.dataDir, id);
+  }
+}
+
+export default OAuthService;

package/src/plugins/server.ts

@@ -0,0 +1,126 @@
+import http from "node:http";
+import { Service, type Context } from "cordis";
+import {
+  DEFAULT_GUILD_HOST,
+  DEFAULT_GUILD_PORT,
+} from "@guild/protocol";
+import { handleRequest } from "../router.ts";
+import { guildEnvOf } from "../start.ts";
+
+export type ServerConfig = {
+  host?: string;
+  port?: number;
+};
+
+export type ListeningInfo = {
+  host: string;
+  port: number;
+  dataDir: string;
+};
+
+export class ServerService extends Service {
+  static inject = ["store", "chat"];
+  readonly node: http.Server;
+  host = "";
+  port = 0;
+  private readonly config: ServerConfig;
+  private readonly listening: Promise<ListeningInfo>;
+  private resolveListening!: (info: ListeningInfo) => void;
+  private rejectListening!: (error: Error) => void;
+  private started = false;
+
+  constructor(ctx: Context, config: ServerConfig = {}) {
+    super(ctx, "server");
+    this.config = config;
+    this.listening = new Promise<ListeningInfo>((resolve, reject) => {
+      this.resolveListening = resolve;
+      this.rejectListening = reject;
+    });
+    void this.listening.catch(() => {});
+
+    const env = () => guildEnvOf(ctx);
+    this.node = http.createServer((req, res) => {
+      const store = ctx.store.guild;
+      void handleRequest(req, res, store, env(), {
+        mcp: Boolean(ctx.get("mcp")),
+        oauth: Boolean(ctx.get("oauth")),
+        harvest: false,
+        onTurnComplete: (turn) => {
+          ctx.emit("guild/turn-complete", turn);
+        },
+        turn: (input) => ctx.chat.reply(input),
+      });
+    });
+    ctx.effect(() => {
+      return () =>
+        new Promise<void>((resolve) => {
+          this.rejectListening(new Error("disposed"));
+          if (!this.node.listening) {
+            resolve();
+            return;
+          }
+          this.node.close(() => resolve());
+        });
+    });
+  }
+
+  whenListening(): Promise<ListeningInfo> {
+    return this.listening;
+  }
+
+  listen(): Promise<ListeningInfo> {
+    if (this.started) return this.listening;
+    this.started = true;
+    const env = guildEnvOf(this.ctx);
+    const host = env.GUILD_HOST ?? this.config.host ?? DEFAULT_GUILD_HOST;
+    const rawPort = env.GUILD_PORT ?? this.config.port ?? DEFAULT_GUILD_PORT;
+    const port = Number(rawPort);
+    if (!Number.isInteger(port) || port < 0 || port > 65535) {
+      const error = new Error(`invalid GUILD_PORT: ${env.GUILD_PORT}`);
+      this.rejectListening(error);
+      throw error;
+    }
+    this.node.once("error", (error) => {
+      this.rejectListening(error);
+    });
+    const dataDir = this.ctx.store.dataDir;
+    this.node.listen(port, host, () => {
+      const address = this.node.address();
+      if (address === null || typeof address === "string") {
+        this.rejectListening(new Error("guildd failed to bind a TCP port"));
+        return;
+      }
+      this.host = address.address;
+      this.port = address.port;
+      const info: ListeningInfo = {
+        host: this.host,
+        port: this.port,
+        dataDir,
+      };
+      this.ctx.emit("guild/listening", info);
+      this.resolveListening(info);
+    });
+    return this.listening;
+  }
+}
+
+export function listenGuildServer(
+  server: http.Server,
+  host: string,
+  port: number,
+): Promise<{ host: string; port: number }> {
+  return new Promise((resolve, reject) => {
+    server.once("error", reject);
+    server.listen(port, host, () => {
+      server.off("error", reject);
+      const address = server.address();
+      if (address === null || typeof address === "string") {
+        reject(new Error("guildd failed to bind a TCP port"));
+        return;
+      }
+      resolve({ host: address.address, port: address.port });
+    });
+  });
+}
+
+export default ServerService;

package/src/plugins/store.ts

@@ -0,0 +1,29 @@
+import { Service, type Context } from "cordis";
+import { defaultDataDir, GuildStore } from "../store.ts";
+import { guildEnvOf } from "../start.ts";
+
+export type StoreConfig = {
+  dataDir?: string;
+};
+
+export class StoreService extends Service {
+  readonly guild: GuildStore;
+  readonly env: NodeJS.ProcessEnv;
+
+  constructor(ctx: Context, config: StoreConfig = {}) {
+    super(ctx, "store");
+    this.env = guildEnvOf(ctx);
+    const dataDir =
+      this.env.GUILD_HOME ?? config.dataDir ?? defaultDataDir(this.env);
+    this.guild = new GuildStore(dataDir);
+    ctx.effect(() => () => {
+      this.guild.close();
+    });
+  }
+
+  get dataDir(): string {
+    return this.guild.dataDir;
+  }
+}
+
+export default StoreService;

package/src/plugins/tools.ts

@@ -0,0 +1,79 @@
+import { Service, type Context } from "cordis";
+import { closeBrowser } from "../browser.ts";
+import { gateTool } from "../harness.ts";
+import {
+  builtinExecute,
+  BUILTIN_TOOL_NAMES,
+  type ToolContext,
+  type ToolOutcome,
+} from "../tools.ts";
+
+export type NamedToolHandler = (
+  args: Record<string, unknown>,
+  ctx: ToolContext,
+) => Promise<ToolOutcome> | ToolOutcome;
+
+export type PrefixToolHandler = (
+  name: string,
+  args: Record<string, unknown>,
+  ctx: ToolContext,
+) => Promise<ToolOutcome> | ToolOutcome;
+
+export class ToolsService extends Service {
+  static inject = ["store"];
+  private readonly named = new Map<string, NamedToolHandler>();
+  private readonly prefixes = new Map<string, PrefixToolHandler>();
+
+  constructor(ctx: Context) {
+    super(ctx, "tools");
+    for (const name of BUILTIN_TOOL_NAMES) {
+      this.register(name, (args, toolCtx) => builtinExecute(name, args, toolCtx));
+    }
+    ctx.effect(() => () => {
+      void closeBrowser();
+    });
+  }
+
+  has(name: string): boolean {
+    if (this.named.has(name)) return true;
+    for (const prefix of this.prefixes.keys()) {
+      if (name.startsWith(prefix)) return true;
+    }
+    return false;
+  }
+
+  register(name: string, handler: NamedToolHandler): () => void {
+    this.named.set(name, handler);
+    const undo = () => {
+      if (this.named.get(name) === handler) this.named.delete(name);
+    };
+    this.ctx.effect(() => undo);
+    return undo;
+  }
+
+  registerPrefix(prefix: string, handler: PrefixToolHandler): () => void {
+    this.prefixes.set(prefix, handler);
+    const undo = () => {
+      if (this.prefixes.get(prefix) === handler) this.prefixes.delete(prefix);
+    };
+    this.ctx.effect(() => undo);
+    return undo;
+  }
+
+  async execute(
+    name: string,
+    args: Record<string, unknown>,
+    toolCtx: ToolContext = {},
+  ): Promise<ToolOutcome> {
+    const refused = gateTool(name, args, toolCtx);
+    if (refused) return refused;
+    const named = this.named.get(name);
+    if (named) return named(args, toolCtx);
+    for (const [prefix, handler] of this.prefixes) {
+      if (name.startsWith(prefix)) return handler(name, args, toolCtx);
+    }
+    return { text: `unknown tool: ${name}`, isError: true };
+  }
+}
+
+export default ToolsService;