@toolkit-cli/toolkode 1.3.7

package/src/channel/index.ts

@@ -0,0 +1,231 @@
+/**
+ * tk_ toolkode — Channel System
+ *
+ * Channels are MCP servers that push events into a running session.
+ * External systems (chat platforms, webhooks, CI) send events through
+ * a channel server, which forwards them to toolkode via MCP notifications.
+ *
+ * Architecture:
+ *   External → Channel MCP Server (local process) → stdio → toolkode session
+ *
+ * Channel servers declare `claude/channel` capability.
+ * Events arrive as `notifications/claude/channel` with content + meta.
+ * Two-way channels expose reply tools via standard MCP tool capability.
+ * Permission relay via `claude/channel/permission` capability.
+ *
+ * NOT experimental. Production feature.
+ */
+import { Log } from "../util/log"
+import { Bus } from "../bus"
+import { BusEvent } from "../bus/bus-event"
+import z from "zod"
+
+const log = Log.create({ service: "channel" })
+
+export namespace Channel {
+  /* ── Types ──────────────────────────────────────────────────── */
+
+  export interface ChannelEvent {
+    source: string
+    content: string
+    meta: Record<string, string>
+    timestamp: number
+  }
+
+  export interface ChannelConfig {
+    name: string
+    type: "plugin" | "server"
+    enabled: boolean
+  }
+
+  export interface PermissionRequest {
+    requestId: string
+    toolName: string
+    description: string
+    inputPreview: string
+  }
+
+  export interface PermissionVerdict {
+    requestId: string
+    behavior: "allow" | "deny"
+  }
+
+  /* ── Events ─────────────────────────────────────────────────── */
+
+  export const Event = {
+    /** Fired when a channel event arrives */
+    Received: BusEvent.define(
+      "channel.received",
+      z.object({
+        source: z.string(),
+        content: z.string(),
+        meta: z.record(z.string(), z.string()).optional(),
+      }),
+    ),
+    /** Fired when a permission verdict arrives from a channel */
+    PermissionVerdict: BusEvent.define(
+      "channel.permission.verdict",
+      z.object({
+        requestId: z.string(),
+        behavior: z.enum(["allow", "deny"]),
+      }),
+    ),
+  }
+
+  /* ── State ──────────────────────────────────────────────────── */
+
+  const channels = new Map<string, ChannelConfig>()
+  const eventHistory: ChannelEvent[] = []
+  let disabled = false
+
+  /** Check if channels are enabled */
+  export function isEnabled(): boolean {
+    return !disabled
+  }
+
+  /** Disable channels */
+  export function disable() {
+    disabled = true
+    log.info("channels disabled")
+  }
+
+  /** Register a channel */
+  export function register(config: ChannelConfig) {
+    if (disabled) {
+      log.warn("cannot register channel: channels are disabled", { name: config.name })
+      return
+    }
+    channels.set(config.name, config)
+    log.info("channel registered", { name: config.name, type: config.type })
+  }
+
+  /** Unregister a channel */
+  export function unregister(name: string) {
+    channels.delete(name)
+    log.info("channel unregistered", { name })
+  }
+
+  /** List registered channels */
+  export function list(): ChannelConfig[] {
+    return Array.from(channels.values())
+  }
+
+  /* ── Event Handling ─────────────────────────────────────────── */
+
+  /**
+   * Handle an incoming channel notification.
+   * Called when an MCP server sends `notifications/claude/channel`.
+   *
+   * The event is:
+   * 1. Validated
+   * 2. Stored in history
+   * 3. Published on the bus for the session to pick up
+   * 4. Formatted as a <channel> tag for injection into the conversation
+   */
+  export function handleNotification(
+    source: string,
+    params: { content: string; meta?: Record<string, string> },
+  ): ChannelEvent {
+    const event: ChannelEvent = {
+      source,
+      content: params.content,
+      meta: params.meta ?? {},
+      timestamp: Date.now(),
+    }
+
+    eventHistory.push(event)
+    // Keep last 100 events
+    if (eventHistory.length > 100) eventHistory.shift()
+
+    // Publish on bus for session consumption
+    Bus.publish(Event.Received, {
+      source: event.source,
+      content: event.content,
+      meta: event.meta,
+    })
+
+    log.info("channel event received", {
+      source,
+      contentLength: params.content.length,
+      metaKeys: Object.keys(params.meta ?? {}),
+    })
+
+    return event
+  }
+
+  /**
+   * Format a channel event as an XML tag for injection into conversation context.
+   *
+   * <channel source="webhook" severity="high" run_id="1234">
+   *   build failed on main
+   * </channel>
+   */
+  export function formatEvent(event: ChannelEvent): string {
+    const attrs = [`source="${event.source}"`]
+    for (const [key, value] of Object.entries(event.meta)) {
+      // Only allow safe attribute names (letters, digits, underscores)
+      if (/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(key)) {
+        attrs.push(`${key}="${escapeAttr(value)}"`)
+      }
+    }
+    return `<channel ${attrs.join(" ")}>${event.content}</channel>`
+  }
+
+  /** Handle permission verdict from a channel */
+  export function handlePermissionVerdict(verdict: PermissionVerdict) {
+    Bus.publish(Event.PermissionVerdict, {
+      requestId: verdict.requestId,
+      behavior: verdict.behavior,
+    })
+    log.info("permission verdict received", {
+      requestId: verdict.requestId,
+      behavior: verdict.behavior,
+    })
+  }
+
+  /**
+   * Send a permission request to all channels that declared the
+   * `claude/channel/permission` capability.
+   */
+  export function sendPermissionRequest(request: PermissionRequest): void {
+    // This would be called by the permission system when a dialog opens.
+    // The actual MCP notification is sent by the MCP layer to servers
+    // that declared the capability.
+    log.info("permission request sent to channels", {
+      requestId: request.requestId,
+      toolName: request.toolName,
+    })
+  }
+
+  /** Get recent events */
+  export function getHistory(limit = 20): ChannelEvent[] {
+    return eventHistory.slice(-limit)
+  }
+
+  /** Clear all state */
+  export function clear() {
+    channels.clear()
+    eventHistory.length = 0
+  }
+
+  /* ── Helpers ────────────────────────────────────────────────── */
+
+  function escapeAttr(value: string): string {
+    return value.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/>/g, "&gt;")
+  }
+
+  /**
+   * Generate a 5-letter request ID for permission relay.
+   * Uses a-z minus 'l' to avoid l/1/I confusion on mobile.
+   */
+  export function generateRequestId(): string {
+    const alphabet = "abcdefghijkmnopqrstuvwxyz" // no 'l'
+    let id = ""
+    const bytes = new Uint8Array(5)
+    crypto.getRandomValues(bytes)
+    for (const b of bytes) {
+      id += alphabet[b % alphabet.length]
+    }
+    return id
+  }
+}

package/src/cli/bootstrap.ts

@@ -0,0 +1,17 @@
+import { InstanceBootstrap } from "../project/bootstrap"
+import { Instance } from "../project/instance"
+
+export async function bootstrap<T>(directory: string, cb: () => Promise<T>) {
+  return Instance.provide({
+    directory,
+    init: InstanceBootstrap,
+    fn: async () => {
+      try {
+        const result = await cb()
+        return result
+      } finally {
+        await Instance.dispose()
+      }
+    },
+  })
+}

package/src/cli/cmd/account.ts

@@ -0,0 +1,257 @@
+import { cmd } from "./cmd"
+import { Duration, Effect, Match, Option } from "effect"
+import { UI } from "../ui"
+import { AccountID, Account, OrgID, PollExpired, type PollResult } from "@/account"
+import { type AccountError } from "@/account/schema"
+import * as Prompt from "../effect/prompt"
+import open from "open"
+
+const openBrowser = (url: string) => Effect.promise(() => open(url).catch(() => undefined))
+
+const println = (msg: string) => Effect.sync(() => UI.println(msg))
+
+const dim = (value: string) => UI.Style.TEXT_DIM + value + UI.Style.TEXT_NORMAL
+
+const activeSuffix = (isActive: boolean) => (isActive ? dim(" (active)") : "")
+
+export const formatAccountLabel = (account: { email: string; url: string }, isActive: boolean) =>
+  `${account.email} ${dim(account.url)}${activeSuffix(isActive)}`
+
+const formatOrgChoiceLabel = (account: { email: string }, org: { name: string }, isActive: boolean) =>
+  `${org.name} (${account.email})${activeSuffix(isActive)}`
+
+export const formatOrgLine = (
+  account: { email: string; url: string },
+  org: { id: string; name: string },
+  isActive: boolean,
+) => {
+  const dot = isActive ? UI.Style.TEXT_SUCCESS + "●" + UI.Style.TEXT_NORMAL : " "
+  const name = isActive ? UI.Style.TEXT_HIGHLIGHT_BOLD + org.name + UI.Style.TEXT_NORMAL : org.name
+  return `  ${dot} ${name}  ${dim(account.email)}  ${dim(account.url)}  ${dim(org.id)}`
+}
+
+const isActiveOrgChoice = (
+  active: Option.Option<{ id: AccountID; active_org_id: OrgID | null }>,
+  choice: { accountID: AccountID; orgID: OrgID },
+) => Option.isSome(active) && active.value.id === choice.accountID && active.value.active_org_id === choice.orgID
+
+const loginEffect = Effect.fn("login")(function* (url: string) {
+  const service = yield* Account.Service
+
+  yield* Prompt.intro("Log in")
+  const login = yield* service.login(url)
+
+  yield* Prompt.log.info("Go to: " + login.url)
+  yield* Prompt.log.info("Enter code: " + login.user)
+  yield* openBrowser(login.url)
+
+  const s = Prompt.spinner()
+  yield* s.start("Waiting for authorization...")
+
+  const poll = (wait: Duration.Duration): Effect.Effect<PollResult, AccountError> =>
+    Effect.gen(function* () {
+      yield* Effect.sleep(wait)
+      const result = yield* service.poll(login)
+      if (result._tag === "PollPending") return yield* poll(wait)
+      if (result._tag === "PollSlow") return yield* poll(Duration.sum(wait, Duration.seconds(5)))
+      return result
+    })
+
+  const result = yield* poll(login.interval).pipe(
+    Effect.timeout(login.expiry),
+    Effect.catchTag("TimeoutError", () => Effect.succeed(new PollExpired())),
+  )
+
+  yield* Match.valueTags(result, {
+    PollSuccess: (r) =>
+      Effect.gen(function* () {
+        yield* s.stop("Logged in as " + r.email)
+        yield* Prompt.outro("Done")
+      }),
+    PollExpired: () => s.stop("Device code expired", 1),
+    PollDenied: () => s.stop("Authorization denied", 1),
+    PollError: (r) => s.stop("Error: " + String(r.cause), 1),
+    PollPending: () => s.stop("Unexpected state", 1),
+    PollSlow: () => s.stop("Unexpected state", 1),
+  })
+})
+
+const logoutEffect = Effect.fn("logout")(function* (email?: string) {
+  const service = yield* Account.Service
+  const accounts = yield* service.list()
+  if (accounts.length === 0) return yield* println("Not logged in")
+
+  if (email) {
+    const match = accounts.find((a) => a.email === email)
+    if (!match) return yield* println("Account not found: " + email)
+    yield* service.remove(match.id)
+    yield* Prompt.outro("Logged out from " + email)
+    return
+  }
+
+  const active = yield* service.active()
+  const activeID = Option.map(active, (a) => a.id)
+
+  yield* Prompt.intro("Log out")
+
+  const opts = accounts.map((a) => {
+    const isActive = Option.isSome(activeID) && activeID.value === a.id
+    return {
+      value: a,
+      label: formatAccountLabel(a, isActive),
+    }
+  })
+
+  const selected = yield* Prompt.select({ message: "Select account to log out", options: opts })
+  if (Option.isNone(selected)) return
+
+  yield* service.remove(selected.value.id)
+  yield* Prompt.outro("Logged out from " + selected.value.email)
+})
+
+interface OrgChoice {
+  orgID: OrgID
+  accountID: AccountID
+  label: string
+}
+
+const switchEffect = Effect.fn("switch")(function* () {
+  const service = yield* Account.Service
+
+  const groups = yield* service.orgsByAccount()
+  if (groups.length === 0) return yield* println("Not logged in")
+
+  const active = yield* service.active()
+
+  const opts = groups.flatMap((group) =>
+    group.orgs.map((org) => {
+      const isActive = isActiveOrgChoice(active, { accountID: group.account.id, orgID: org.id })
+      return {
+        value: { orgID: org.id, accountID: group.account.id, label: org.name },
+        label: formatOrgChoiceLabel(group.account, org, isActive),
+      }
+    }),
+  )
+  if (opts.length === 0) return yield* println("No orgs found")
+
+  yield* Prompt.intro("Switch org")
+
+  const selected = yield* Prompt.select<OrgChoice>({ message: "Select org", options: opts })
+  if (Option.isNone(selected)) return
+
+  const choice = selected.value
+  yield* service.use(choice.accountID, Option.some(choice.orgID))
+  yield* Prompt.outro("Switched to " + choice.label)
+})
+
+const orgsEffect = Effect.fn("orgs")(function* () {
+  const service = yield* Account.Service
+
+  const groups = yield* service.orgsByAccount()
+  if (groups.length === 0) return yield* println("No accounts found")
+  if (!groups.some((group) => group.orgs.length > 0)) return yield* println("No orgs found")
+
+  const active = yield* service.active()
+
+  for (const group of groups) {
+    for (const org of group.orgs) {
+      const isActive = isActiveOrgChoice(active, { accountID: group.account.id, orgID: org.id })
+      yield* println(formatOrgLine(group.account, org, isActive))
+    }
+  }
+})
+
+const openEffect = Effect.fn("open")(function* () {
+  const service = yield* Account.Service
+  const active = yield* service.active()
+  if (Option.isNone(active)) return yield* println("No active account")
+
+  const url = active.value.url
+  yield* openBrowser(url)
+  yield* Prompt.outro("Opened " + url)
+})
+
+export const LoginCommand = cmd({
+  command: "login <url>",
+  describe: false,
+  builder: (yargs) =>
+    yargs.positional("url", {
+      describe: "server URL",
+      type: "string",
+      demandOption: true,
+    }),
+  async handler(args) {
+    UI.empty()
+    await Account.runPromise((_svc) => loginEffect(args.url))
+  },
+})
+
+export const LogoutCommand = cmd({
+  command: "logout [email]",
+  describe: false,
+  builder: (yargs) =>
+    yargs.positional("email", {
+      describe: "account email to log out from",
+      type: "string",
+    }),
+  async handler(args) {
+    UI.empty()
+    await Account.runPromise((_svc) => logoutEffect(args.email))
+  },
+})
+
+export const SwitchCommand = cmd({
+  command: "switch",
+  describe: false,
+  async handler() {
+    UI.empty()
+    await Account.runPromise((_svc) => switchEffect())
+  },
+})
+
+export const OrgsCommand = cmd({
+  command: "orgs",
+  describe: false,
+  async handler() {
+    UI.empty()
+    await Account.runPromise((_svc) => orgsEffect())
+  },
+})
+
+export const OpenCommand = cmd({
+  command: "open",
+  describe: false,
+  async handler() {
+    UI.empty()
+    await Account.runPromise((_svc) => openEffect())
+  },
+})
+
+export const ConsoleCommand = cmd({
+  command: "console",
+  describe: false,
+  builder: (yargs) =>
+    yargs
+      .command({
+        ...LoginCommand,
+        describe: "log in to console",
+      })
+      .command({
+        ...LogoutCommand,
+        describe: "log out from console",
+      })
+      .command({
+        ...SwitchCommand,
+        describe: "switch active org",
+      })
+      .command({
+        ...OrgsCommand,
+        describe: "list orgs",
+      })
+      .command({
+        ...OpenCommand,
+        describe: "open active console account",
+      })
+      .demandCommand(),
+  async handler() {},
+})

package/src/cli/cmd/acp.ts

@@ -0,0 +1,70 @@
+import { Log } from "@/util/log"
+import { bootstrap } from "../bootstrap"
+import { cmd } from "./cmd"
+import { AgentSideConnection, ndJsonStream } from "@agentclientprotocol/sdk"
+import { ACP } from "@/acp/agent"
+import { Server } from "@/server/server"
+import { createOpencodeClient } from "@toolkit-cli/sdk/v2"
+import { withNetworkOptions, resolveNetworkOptions } from "../network"
+
+const log = Log.create({ service: "acp-command" })
+
+export const AcpCommand = cmd({
+  command: "acp",
+  describe: "start ACP (Agent Client Protocol) server",
+  builder: (yargs) => {
+    return withNetworkOptions(yargs).option("cwd", {
+      describe: "working directory",
+      type: "string",
+      default: process.cwd(),
+    })
+  },
+  handler: async (args) => {
+    process.env.OPENCODE_CLIENT = "acp"
+    await bootstrap(process.cwd(), async () => {
+      const opts = await resolveNetworkOptions(args)
+      const server = Server.listen(opts)
+
+      const sdk = createOpencodeClient({
+        baseUrl: `http://${server.hostname}:${server.port}`,
+      })
+
+      const input = new WritableStream<Uint8Array>({
+        write(chunk) {
+          return new Promise<void>((resolve, reject) => {
+            process.stdout.write(chunk, (err) => {
+              if (err) {
+                reject(err)
+              } else {
+                resolve()
+              }
+            })
+          })
+        },
+      })
+      const output = new ReadableStream<Uint8Array>({
+        start(controller) {
+          process.stdin.on("data", (chunk: Buffer) => {
+            controller.enqueue(new Uint8Array(chunk))
+          })
+          process.stdin.on("end", () => controller.close())
+          process.stdin.on("error", (err) => controller.error(err))
+        },
+      })
+
+      const stream = ndJsonStream(input, output)
+      const agent = await ACP.init({ sdk })
+
+      new AgentSideConnection((conn) => {
+        return agent.create(conn, { sdk })
+      }, stream)
+
+      log.info("setup connection")
+      process.stdin.resume()
+      await new Promise((resolve, reject) => {
+        process.stdin.on("end", resolve)
+        process.stdin.on("error", reject)
+      })
+    })
+  },
+})