anymous 1.3.0 → 1.3.2

package/src/mcp/oauth-callback.ts

@@ -1,194 +0,0 @@
-import { createConnection } from "net"
-import { createServer } from "http"
-import { OauthCallbackPage } from "@anymous-ai/core/oauth/page"
-import { OAUTH_CALLBACK_PORT, OAUTH_CALLBACK_PATH, parseRedirectUri } from "./oauth-provider"
-
-const OAUTH_CALLBACK_HOST = "127.0.0.1"
-
-// Current callback server configuration (may differ from defaults if custom redirectUri is used)
-let currentPort = OAUTH_CALLBACK_PORT
-let currentPath = OAUTH_CALLBACK_PATH
-
-interface PendingAuth {
-  resolve: (code: string) => void
-  reject: (error: Error) => void
-  timeout: ReturnType<typeof setTimeout>
-}
-
-let server: ReturnType<typeof createServer> | undefined
-const pendingAuths = new Map<string, PendingAuth>()
-// Reverse index: mcpName → oauthState, so cancelPending(mcpName) can
-// find the right entry in pendingAuths (which is keyed by oauthState).
-const mcpNameToState = new Map<string, string>()
-
-const CALLBACK_TIMEOUT_MS = 5 * 60 * 1000 // 5 minutes
-
-function cleanupStateIndex(oauthState: string) {
-  for (const [name, state] of mcpNameToState) {
-    if (state === oauthState) {
-      mcpNameToState.delete(name)
-      break
-    }
-  }
-}
-
-function stopIfIdle() {
-  if (pendingAuths.size > 0 || !server) return
-
-  server.close()
-  server = undefined
-}
-
-function handleRequest(req: import("http").IncomingMessage, res: import("http").ServerResponse) {
-  const url = new URL(req.url || "/", `http://localhost:${currentPort}`)
-
-  if (url.pathname !== currentPath) {
-    res.writeHead(404)
-    res.end("Not found")
-    return
-  }
-
-  const code = url.searchParams.get("code")
-  const state = url.searchParams.get("state")
-  const error = url.searchParams.get("error")
-  const errorDescription = url.searchParams.get("error_description")
-
-  // Enforce state parameter presence
-  if (!state) {
-    const errorMsg = "Missing required state parameter - potential CSRF attack"
-    res.writeHead(400, { "Content-Type": "text/html; charset=utf-8" })
-    res.end(OauthCallbackPage.error(errorMsg, { provider: "MCP" }))
-    return
-  }
-
-  if (error) {
-    const errorMsg = errorDescription || error
-    if (pendingAuths.has(state)) {
-      const pending = pendingAuths.get(state)!
-      clearTimeout(pending.timeout)
-      pendingAuths.delete(state)
-      cleanupStateIndex(state)
-      pending.reject(new Error(errorMsg))
-    }
-    res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" })
-    res.end(OauthCallbackPage.error(errorMsg, { provider: "MCP" }))
-    stopIfIdle()
-    return
-  }
-
-  if (!code) {
-    res.writeHead(400, { "Content-Type": "text/html; charset=utf-8" })
-    res.end(OauthCallbackPage.error("No authorization code provided", { provider: "MCP" }))
-    return
-  }
-
-  // Validate state parameter
-  if (!pendingAuths.has(state)) {
-    const errorMsg = "Invalid or expired state parameter - potential CSRF attack"
-    res.writeHead(400, { "Content-Type": "text/html; charset=utf-8" })
-    res.end(OauthCallbackPage.error(errorMsg, { provider: "MCP" }))
-    return
-  }
-
-  const pending = pendingAuths.get(state)!
-
-  clearTimeout(pending.timeout)
-  pendingAuths.delete(state)
-  cleanupStateIndex(state)
-  pending.resolve(code)
-
-  res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" })
-  res.end(OauthCallbackPage.success({ provider: "MCP" }))
-  stopIfIdle()
-}
-
-export async function ensureRunning(redirectUri?: string): Promise<void> {
-  // Parse the redirect URI to get port and path (uses defaults if not provided)
-  const { port, path } = parseRedirectUri(redirectUri)
-
-  // If server is running on a different port/path, stop it first
-  if (server && (currentPort !== port || currentPath !== path)) {
-    await stop()
-  }
-
-  if (server) return
-
-  const running = await isPortInUse(port)
-  if (running) {
-    return
-  }
-
-  currentPort = port
-  currentPath = path
-
-  server = createServer(handleRequest)
-  await new Promise<void>((resolve, reject) => {
-    server!.listen(currentPort, OAUTH_CALLBACK_HOST, () => {
-      resolve()
-    })
-    server!.on("error", reject)
-  })
-}
-
-export function waitForCallback(oauthState: string, mcpName?: string): Promise<string> {
-  if (mcpName) mcpNameToState.set(mcpName, oauthState)
-  return new Promise((resolve, reject) => {
-    const timeout = setTimeout(() => {
-      if (pendingAuths.has(oauthState)) {
-        pendingAuths.delete(oauthState)
-        if (mcpName) mcpNameToState.delete(mcpName)
-        reject(new Error("OAuth callback timeout - authorization took too long"))
-        stopIfIdle()
-      }
-    }, CALLBACK_TIMEOUT_MS)
-
-    pendingAuths.set(oauthState, { resolve, reject, timeout })
-  })
-}
-
-export function cancelPending(mcpName: string): void {
-  // Look up the oauthState for this mcpName via the reverse index
-  const oauthState = mcpNameToState.get(mcpName)
-  const key = oauthState ?? mcpName
-  const pending = pendingAuths.get(key)
-  if (pending) {
-    clearTimeout(pending.timeout)
-    pendingAuths.delete(key)
-    mcpNameToState.delete(mcpName)
-    pending.reject(new Error("Authorization cancelled"))
-    stopIfIdle()
-  }
-}
-
-export async function isPortInUse(port: number = OAUTH_CALLBACK_PORT): Promise<boolean> {
-  return new Promise((resolve) => {
-    const socket = createConnection(port, "127.0.0.1")
-    socket.on("connect", () => {
-      socket.destroy()
-      resolve(true)
-    })
-    socket.on("error", () => {
-      resolve(false)
-    })
-  })
-}
-
-export async function stop(): Promise<void> {
-  if (server) {
-    await new Promise<void>((resolve) => server!.close(() => resolve()))
-    server = undefined
-  }
-
-  for (const [_name, pending] of pendingAuths) {
-    clearTimeout(pending.timeout)
-    pending.reject(new Error("OAuth callback server stopped"))
-  }
-  pendingAuths.clear()
-  mcpNameToState.clear()
-}
-
-export function isRunning(): boolean {
-  return server !== undefined
-}
-
-export * as McpOAuthCallback from "./oauth-callback"

package/src/mcp/oauth-provider.ts

@@ -1,259 +0,0 @@
-import type { OAuthClientProvider } from "@modelcontextprotocol/sdk/client/auth.js"
-import type {
-  OAuthClientMetadata,
-  OAuthTokens,
-  OAuthClientInformation,
-  OAuthClientInformationFull,
-} from "@modelcontextprotocol/sdk/shared/auth.js"
-import { Effect } from "effect"
-import type { McpAuth } from "./auth"
-
-const OAUTH_CALLBACK_PORT = 19876
-const OAUTH_CALLBACK_PATH = "/mcp/oauth/callback"
-
-export interface McpOAuthConfig {
-  clientId?: string
-  clientSecret?: string
-  scope?: string
-  callbackPort?: number
-  redirectUri?: string
-}
-
-export interface McpOAuthCallbacks {
-  onRedirect: (url: URL) => void | Promise<void>
-}
-
-export class McpOAuthProvider implements OAuthClientProvider {
-  constructor(
-    protected mcpName: string,
-    protected serverUrl: string,
-    protected config: McpOAuthConfig,
-    private callbacks: McpOAuthCallbacks,
-    protected auth: McpAuth.Interface,
-  ) {}
-
-  get redirectUrl(): string {
-    if (this.config.redirectUri) {
-      return this.config.redirectUri
-    }
-    const port = this.config.callbackPort ?? OAUTH_CALLBACK_PORT
-    return `http://127.0.0.1:${port}${OAUTH_CALLBACK_PATH}`
-  }
-
-  get clientMetadata(): OAuthClientMetadata {
-    return {
-      redirect_uris: [this.redirectUrl],
-      client_name: "anymous",
-      client_uri: "https://anymous-cli.vercel.app",
-      grant_types: ["authorization_code", "refresh_token"],
-      response_types: ["code"],
-      token_endpoint_auth_method: this.config.clientSecret ? "client_secret_post" : "none",
-      ...(this.config.scope ? { scope: this.config.scope } : {}),
-    }
-  }
-
-  async clientInformation(): Promise<OAuthClientInformation | undefined> {
-    if (this.config.clientId) {
-      return {
-        client_id: this.config.clientId,
-        client_secret: this.config.clientSecret,
-      }
-    }
-
-    // Check stored client info (from dynamic registration)
-    // Use getForUrl to validate credentials are for the current server URL
-    const entry = await Effect.runPromise(this.auth.getForUrl(this.mcpName, this.serverUrl))
-    if (entry?.clientInfo) {
-      // Check if client secret has expired
-      if (entry.clientInfo.clientSecretExpiresAt && entry.clientInfo.clientSecretExpiresAt < Date.now() / 1000) {
-        return undefined
-      }
-      return {
-        client_id: entry.clientInfo.clientId,
-        client_secret: entry.clientInfo.clientSecret,
-      }
-    }
-
-    // No client info or URL changed - will trigger dynamic registration
-    return undefined
-  }
-
-  async saveClientInformation(info: OAuthClientInformationFull): Promise<void> {
-    await Effect.runPromise(
-      this.auth.updateClientInfo(
-        this.mcpName,
-        {
-          clientId: info.client_id,
-          clientSecret: info.client_secret,
-          clientIdIssuedAt: info.client_id_issued_at,
-          clientSecretExpiresAt: info.client_secret_expires_at,
-        },
-        this.serverUrl,
-      ),
-    )
-  }
-
-  async tokens(): Promise<OAuthTokens | undefined> {
-    // Use getForUrl to validate tokens are for the current server URL
-    const entry = await Effect.runPromise(this.auth.getForUrl(this.mcpName, this.serverUrl))
-    if (!entry?.tokens) return undefined
-
-    return {
-      access_token: entry.tokens.accessToken,
-      token_type: "Bearer",
-      refresh_token: entry.tokens.refreshToken,
-      expires_in: entry.tokens.expiresAt
-        ? Math.max(0, Math.floor(entry.tokens.expiresAt - Date.now() / 1000))
-        : undefined,
-      scope: entry.tokens.scope,
-    }
-  }
-
-  async saveTokens(tokens: OAuthTokens): Promise<void> {
-    await Effect.runPromise(
-      this.auth.updateTokens(
-        this.mcpName,
-        {
-          accessToken: tokens.access_token,
-          refreshToken: tokens.refresh_token,
-          expiresAt: tokens.expires_in ? Date.now() / 1000 + tokens.expires_in : undefined,
-          scope: tokens.scope,
-        },
-        this.serverUrl,
-      ),
-    )
-  }
-
-  async redirectToAuthorization(authorizationUrl: URL): Promise<void> {
-    await this.callbacks.onRedirect(authorizationUrl)
-  }
-
-  async saveCodeVerifier(codeVerifier: string): Promise<void> {
-    await Effect.runPromise(this.auth.updateCodeVerifier(this.mcpName, codeVerifier))
-  }
-
-  async codeVerifier(): Promise<string> {
-    const entry = await Effect.runPromise(this.auth.get(this.mcpName))
-    if (!entry?.codeVerifier) {
-      throw new Error(`No code verifier saved for MCP server: ${this.mcpName}`)
-    }
-    return entry.codeVerifier
-  }
-
-  async saveState(state: string): Promise<void> {
-    await Effect.runPromise(this.auth.updateOAuthState(this.mcpName, state))
-  }
-
-  async state(): Promise<string> {
-    const entry = await Effect.runPromise(this.auth.get(this.mcpName))
-    if (entry?.oauthState) {
-      return entry.oauthState
-    }
-
-    // Generate a new state if none exists — the SDK calls state() as a
-    // generator, not just a reader, so we need to produce a value even when
-    // startAuth() hasn't pre-saved one (e.g. during automatic auth on first
-    // connect).
-    const newState = Array.from(crypto.getRandomValues(new Uint8Array(32)))
-      .map((b) => b.toString(16).padStart(2, "0"))
-      .join("")
-    await Effect.runPromise(this.auth.updateOAuthState(this.mcpName, newState))
-    return newState
-  }
-
-  async invalidateCredentials(type: "all" | "client" | "tokens"): Promise<void> {
-    const entry = await Effect.runPromise(this.auth.get(this.mcpName))
-    if (!entry) return
-    switch (type) {
-      case "all":
-        await Effect.runPromise(this.auth.remove(this.mcpName))
-        break
-      case "client":
-        delete entry.clientInfo
-        await Effect.runPromise(this.auth.set(this.mcpName, entry))
-        break
-      case "tokens":
-        delete entry.tokens
-        await Effect.runPromise(this.auth.set(this.mcpName, entry))
-        break
-    }
-  }
-}
-
-export class McpOAuthPendingProvider extends McpOAuthProvider {
-  private pendingClientInfo?: OAuthClientInformationFull
-  private pendingTokens?: OAuthTokens
-
-  override async clientInformation(): Promise<OAuthClientInformation | undefined> {
-    if (!this.config.clientId) return this.pendingClientInfo
-    return {
-      client_id: this.config.clientId,
-      client_secret: this.config.clientSecret,
-    }
-  }
-
-  override async saveClientInformation(info: OAuthClientInformationFull): Promise<void> {
-    this.pendingClientInfo = info
-  }
-
-  override async tokens(): Promise<OAuthTokens | undefined> {
-    return this.pendingTokens
-  }
-
-  override async saveTokens(tokens: OAuthTokens): Promise<void> {
-    this.pendingTokens = tokens
-  }
-
-  override async invalidateCredentials(type: "all" | "client" | "tokens"): Promise<void> {
-    if (type === "all" || type === "client") this.pendingClientInfo = undefined
-    if (type === "all" || type === "tokens") this.pendingTokens = undefined
-  }
-
-  async commit(): Promise<void> {
-    if (!this.pendingTokens) return
-    await Effect.runPromise(
-      this.auth.set(
-        this.mcpName,
-        {
-          tokens: {
-            accessToken: this.pendingTokens.access_token,
-            refreshToken: this.pendingTokens.refresh_token,
-            expiresAt: this.pendingTokens.expires_in ? Date.now() / 1000 + this.pendingTokens.expires_in : undefined,
-            scope: this.pendingTokens.scope,
-          },
-          clientInfo:
-            this.pendingClientInfo && !this.config.clientId
-              ? {
-                  clientId: this.pendingClientInfo.client_id,
-                  clientSecret: this.pendingClientInfo.client_secret,
-                  clientIdIssuedAt: this.pendingClientInfo.client_id_issued_at,
-                  clientSecretExpiresAt: this.pendingClientInfo.client_secret_expires_at,
-                }
-              : undefined,
-        },
-        this.serverUrl,
-      ),
-    )
-  }
-}
-
-export { OAUTH_CALLBACK_PORT, OAUTH_CALLBACK_PATH }
-
-/**
- * Parse a redirect URI to extract port and path for the callback server.
- * Returns defaults if the URI can't be parsed.
- */
-export function parseRedirectUri(redirectUri?: string): { port: number; path: string } {
-  if (!redirectUri) {
-    return { port: OAUTH_CALLBACK_PORT, path: OAUTH_CALLBACK_PATH }
-  }
-
-  try {
-    const url = new URL(redirectUri)
-    const port = url.port ? parseInt(url.port, 10) : url.protocol === "https:" ? 443 : 80
-    const path = url.pathname || OAUTH_CALLBACK_PATH
-    return { port, path }
-  } catch {
-    return { port: OAUTH_CALLBACK_PORT, path: OAUTH_CALLBACK_PATH }
-  }
-}

package/src/memory/memory.ts

@@ -1,133 +0,0 @@
-import { LayerNode } from "@anymous-ai/core/effect/layer-node"
-import { Effect, Layer, Context, Schema } from "effect"
-import { FSUtil } from "@anymous-ai/core/fs-util"
-import { Global } from "@anymous-ai/core/global"
-import { InstanceState } from "@/effect/instance-state"
-import path from "path"
-
-const MemoryEntry = Schema.Struct({
-  key: Schema.String,
-  value: Schema.String,
-  timestamp: Schema.Number,
-  sessionID: Schema.optional(Schema.String),
-  scope: Schema.optional(Schema.String),
-})
-
-const MemoryStore = Schema.Struct({
-  version: Schema.Literal(1),
-  memories: Schema.Array(MemoryEntry),
-})
-
-interface MemoryEntryType extends Schema.Schema.Type<typeof MemoryEntry> {}
-interface MemoryStoreType extends Schema.Schema.Type<typeof MemoryStore> {}
-
-export interface Interface {
-  readonly read: (key: string) => Effect.Effect<MemoryEntryType | undefined>
-  readonly write: (key: string, value: string, sessionID?: string) => Effect.Effect<void>
-  readonly list: () => Effect.Effect<MemoryEntryType[]>
-  readonly delete: (key: string) => Effect.Effect<boolean>
-  readonly allText: () => Effect.Effect<string | undefined>
-}
-
-export class Service extends Context.Service<Service, Interface>()("@anymous/Memory") {}
-
-const memoryFilePath = (global: { config: string }) => path.join(global.config, "memory.json")
-
-const loadStore = (fs: FSUtil.Interface, filePath: string) =>
-  Effect.gen(function* () {
-    const exists = yield* fs.exists(filePath)
-    if (!exists) {
-      return { version: 1, memories: [] } as MemoryStoreType
-    }
-    const raw = yield* fs.readFileString(filePath)
-    const parsed = JSON.parse(raw) as unknown
-    const decoded = yield* Effect.sync(() => Schema.decodeUnknownSync(MemoryStore)(parsed)).pipe(
-      Effect.catch(() => Effect.succeed({ version: 1, memories: [] } as MemoryStoreType)),
-    )
-    return decoded
-  })
-
-const saveStore = (fs: FSUtil.Interface, filePath: string, store: MemoryStoreType) =>
-  Effect.gen(function* () {
-    yield* fs.writeFileString(filePath, JSON.stringify(store, null, 2))
-  })
-
-// Resolve the current workspace scope. Falls back to the process-wide default workspace
-// when the effect is run outside a project instance (e.g. CLI/global context).
-const currentScope = Effect.map(InstanceState.workspaceID, (id) => id ?? undefined)
-
-const layer = Layer.effect(
-  Service,
-  Effect.gen(function* () {
-    const fs = yield* FSUtil.Service
-    const global = yield* Global.Service
-    const filePath = memoryFilePath(global)
-
-    const read: Interface["read"] = Effect.fn("Memory.read")(function* (key: string) {
-      const store = yield* loadStore(fs, filePath).pipe(Effect.orDie)
-      return store.memories.find((m) => m.key === key)
-    })
-
-    const write: Interface["write"] = Effect.fn("Memory.write")(function* (
-      key: string,
-      value: string,
-      sessionID?: string,
-    ) {
-      const scope = yield* currentScope
-      const store = yield* loadStore(fs, filePath).pipe(Effect.orDie)
-      const memories = [...store.memories]
-      const existing = memories.findIndex((m) => m.key === key && m.scope === scope)
-      const entry: MemoryEntryType = {
-        key,
-        value,
-        timestamp: Date.now(),
-        ...(sessionID ? { sessionID } : {}),
-        ...(scope ? { scope } : {}),
-      }
-      if (existing >= 0) {
-        memories[existing] = entry
-      } else {
-        memories.push(entry)
-      }
-      yield* saveStore(fs, filePath, { ...store, memories }).pipe(Effect.orDie)
-    })
-
-    const list: Interface["list"] = Effect.fn("Memory.list")(function* () {
-      const scope = yield* currentScope
-      const store = yield* loadStore(fs, filePath).pipe(Effect.orDie)
-      return store.memories.filter((m) => m.scope === scope)
-    })
-
-    const remove: Interface["delete"] = Effect.fn("Memory.delete")(function* (key: string) {
-      const scope = yield* currentScope
-      const store = yield* loadStore(fs, filePath).pipe(Effect.orDie)
-      const memories = [...store.memories]
-      const idx = memories.findIndex((m) => m.key === key && m.scope === scope)
-      if (idx < 0) return false
-      memories.splice(idx, 1)
-      yield* saveStore(fs, filePath, { ...store, memories }).pipe(Effect.orDie)
-      return true
-    })
-
-    const allText: Interface["allText"] = Effect.fn("Memory.allText")(function* () {
-      const scope = yield* currentScope
-      const store = yield* loadStore(fs, filePath).pipe(Effect.orDie)
-      // Project-scoped memories are visible only within their own project; unscoped
-      // entries remain global (shared context for every workspace).
-      const entries = store.memories.filter((m) => m.scope === undefined || m.scope === scope)
-      if (entries.length === 0) return undefined
-      const lines = entries.map((m) => `- ${m.key}: ${m.value}`)
-      return `## Shared Context / Memory\n\n${lines.join("\n")}`
-    })
-
-    return Service.of({ read, write, list, delete: remove, allText })
-  }),
-)
-
-export const node = LayerNode.make({
-  service: Service,
-  layer: layer.pipe(Layer.orDie),
-  deps: [FSUtil.node, Global.node],
-})
-
-export * as Memory from "./memory"

package/src/node.ts

@@ -1,4 +0,0 @@
-export { Config } from "@/config/config"
-export { Server } from "./server/server"
-export { bootstrap } from "./cli/bootstrap"
-export { Database } from "@anymous-ai/core/database/database"