typeclaw 0.3.0 → 0.4.0

package/src/channels/schema.ts

@@ -1,6 +1,6 @@
 import { z } from 'zod'
 
-export const ADAPTER_IDS = ['discord-bot', 'kakaotalk', 'slack-bot', 'telegram-bot'] as const
+export const ADAPTER_IDS = ['discord-bot', 'github', 'kakaotalk', 'slack-bot', 'telegram-bot'] as const
 
 export type AdapterId = (typeof ADAPTER_IDS)[number]
 
@@ -99,6 +99,33 @@ const adapterSchema = z.object({
   enabled: z.boolean().default(true),
 })
 
+export const DEFAULT_GITHUB_EVENT_ALLOWLIST = [
+  'issue_comment.created',
+  'pull_request_review_comment.created',
+  'discussion_comment.created',
+  'issues.opened',
+  'pull_request.opened',
+  'discussion.created',
+  'pull_request_review.submitted',
+] as const
+
+const githubChannelSchema = adapterSchema.extend({
+  // Optional now (PR 2): when omitted and a `tunnels[]` entry with
+  // `for: { kind: 'channel', name: 'github' }` exists, the runtime resolves
+  // the URL from the tunnel manager via the adapter's `tunnelUrl` callback.
+  // The github adapter skips webhook registration when no effective URL is available.
+  webhookUrl: z.string().url().optional(),
+  webhookPort: z.number().int().positive().default(8975),
+  eventAllowlist: z.array(z.string()).default([...DEFAULT_GITHUB_EVENT_ALLOWLIST]),
+  // Repositories whose webhooks the adapter manages. Each entry is an
+  // `owner/name` slug. On adapter start(), TypeClaw registers a webhook
+  // pointing at webhookUrl for every repo here (idempotent: existing hooks
+  // at the same URL are updated). On stop(), every hook TypeClaw created
+  // this session is deleted so a restart with a different webhookUrl (e.g.
+  // a tunnel reassigning a URL) doesn't leave orphaned hooks on GitHub.
+  repos: z.array(z.string()).default([]),
+})
+
 // KakaoTalk uses the same shape as every other adapter. There used to be an
 // `autoMarkRead` opt-in here; the adapter now fires a LOCO NOTIREAD ack on
 // every inbound MSG event unconditionally (see kakaotalk.ts) so the sender's
@@ -112,6 +139,7 @@ const adapterSchema = z.object({
 export const channelsSchema = z
   .object({
     'discord-bot': adapterSchema.optional(),
+    github: githubChannelSchema.optional(),
     kakaotalk: adapterSchema.optional(),
     'slack-bot': adapterSchema.optional(),
     'telegram-bot': adapterSchema.optional(),
@@ -120,4 +148,6 @@ export const channelsSchema = z
 
 export type EngagementConfig = z.infer<typeof engagementSchema>
 export type ChannelAdapterConfig = z.infer<typeof adapterSchema>
+type ParsedGithubAdapterConfig = z.infer<typeof githubChannelSchema>
+export type GithubAdapterConfig = ParsedGithubAdapterConfig
 export type ChannelsConfig = z.infer<typeof channelsSchema>

package/src/channels/tunnel-bridge.ts

@@ -0,0 +1,51 @@
+import type { Stream } from '@/stream'
+import { isTunnelUrlChangedPayload } from '@/tunnels'
+
+import type { AdapterId } from './schema'
+
+export type TunnelBridgeLogger = {
+  info: (msg: string) => void
+  warn: (msg: string) => void
+  error: (msg: string) => void
+}
+
+export type TunnelBridgeChannelManager = {
+  restartAdapter: (name: AdapterId) => Promise<void>
+}
+
+export type TunnelBridgeOptions = {
+  stream: Stream
+  channelManager: TunnelBridgeChannelManager
+  logger?: TunnelBridgeLogger
+}
+
+export type TunnelBridge = {
+  stop: () => void
+}
+
+const consoleLogger: TunnelBridgeLogger = {
+  info: (msg) => console.log(msg),
+  warn: (msg) => console.warn(msg),
+  error: (msg) => console.error(msg),
+}
+
+export function createTunnelBridge(options: TunnelBridgeOptions): TunnelBridge {
+  const logger = options.logger ?? consoleLogger
+  // Subscribe synchronously; run/index.ts must create this bridge before
+  // tunnelManager.start() so an initial provider URL broadcast cannot be missed.
+  const unsubscribe = options.stream.subscribe({ target: { kind: 'broadcast' } }, (msg) => {
+    const payload = msg.payload
+    if (!isTunnelUrlChangedPayload(payload)) return
+    if (payload.for.kind !== 'channel') return
+    const name = (payload.for as { name?: unknown }).name
+    if (typeof name !== 'string') return
+    logger.info(`[tunnels] ${name} URL → restarting adapter`)
+    void options.channelManager.restartAdapter(name as AdapterId).catch((err: unknown) => {
+      logger.error(`[tunnels] failed to restart ${name} adapter: ${err instanceof Error ? err.message : String(err)}`)
+    })
+  })
+
+  return {
+    stop: unsubscribe,
+  }
+}

package/src/cli/builtins.ts

@@ -0,0 +1,28 @@
+// Single source of truth for the top-level `typeclaw` subcommands that the
+// CLI dispatches via citty. Plugin commands MUST NOT shadow these names.
+// `src/cli/index.ts` consumes this for argv interception; `src/plugin/registry.ts`
+// consumes it to reject plugin commands that collide.
+export const BUILTIN_COMMAND_NAMES = [
+  'init',
+  'run',
+  'tui',
+  'start',
+  'stop',
+  'restart',
+  'status',
+  'reload',
+  'logs',
+  'shell',
+  'compose',
+  'channel',
+  'cron',
+  'tunnel',
+  'role',
+  'provider',
+  'model',
+  'doctor',
+  'usage',
+  '_hostd',
+] as const
+
+export type BuiltinCommandName = (typeof BUILTIN_COMMAND_NAMES)[number]