@toolkit-cli/toolkode 1.3.7 → 1.3.9

package/src/channel/index.ts

@@ -1,231 +0,0 @@
-/**
- * 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

@@ -1,17 +0,0 @@
-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

@@ -1,257 +0,0 @@
-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

@@ -1,70 +0,0 @@
-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)
-      })
-    })
-  },
-})