@miaws/miaw 1.18.5 → 1.18.6

package/src/cli/cmd/acp.ts

@@ -1,73 +0,0 @@
-import { Effect } from "effect"
-import { effectCmd } from "../effect-cmd"
-import { AgentSideConnection, ndJsonStream } from "@agentclientprotocol/sdk"
-import { ServerAuth } from "@/server/auth"
-import { createMiawClient } from "@miaw/sdk/v2"
-import { withNetworkOptions, resolveNetworkOptions } from "../network"
-import { ACPProfile } from "@/acp/profile"
-
-export const AcpCommand = effectCmd({
-  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: Effect.fn("Cli.acp")(function* (args) {
-    const { Server } = yield* Effect.promise(() => import("@/server/server"))
-    const { ACP } = yield* Effect.promise(() => import("@/acp/agent"))
-    ACPProfile.mark("cli.acp.handler")
-    process.env.MIAW_CLIENT = "acp"
-    const opts = yield* resolveNetworkOptions(args)
-    const server = yield* Effect.promise(() => ACPProfile.measure("cli.acp.server.listen", () => Server.listen(opts)))
-
-    const sdk = createMiawClient({
-      baseUrl: `http://${server.hostname}:${server.port}`,
-      headers: ServerAuth.headers(),
-    })
-
-    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 = ACP.init({ sdk })
-
-    new AgentSideConnection((conn) => {
-      ACPProfile.mark("cli.acp.connection.create")
-      return agent.create(conn)
-    }, stream)
-
-    yield* Effect.logInfo("setup connection")
-    process.stdin.resume()
-    yield* Effect.promise(
-      () =>
-        new Promise<void>((resolve, reject) => {
-          process.stdin.on("end", () => resolve())
-          process.stdin.on("error", reject)
-        }),
-    )
-  }),
-})

package/src/cli/cmd/agent.ts

@@ -1,253 +0,0 @@
-import { cmd } from "./cmd"
-import * as prompts from "@clack/prompts"
-import { UI } from "../ui"
-import { Global } from "@miaw/core/global"
-import path from "path"
-import fs from "fs/promises"
-import { Filesystem } from "@/util/filesystem"
-import matter from "gray-matter"
-import { EOL } from "os"
-import type { Argv } from "yargs"
-import { Effect } from "effect"
-import { effectCmd } from "../effect-cmd"
-
-type AgentMode = "all" | "primary" | "subagent"
-
-// Permission keys (not raw tool names). Multiple tools can map to a single
-// permission — e.g. write/edit/apply_patch all gate on `edit` — so we configure
-// agents at the permission level to match how the runtime actually enforces it.
-const AVAILABLE_PERMISSIONS = [
-  "bash",
-  "read",
-  "edit",
-  "glob",
-  "grep",
-  "webfetch",
-  "task",
-  "todowrite",
-  "websearch",
-  "lsp",
-  "skill",
-]
-
-const AgentCreateCommand = effectCmd({
-  command: "create",
-  describe: "create a new agent",
-  builder: (yargs: Argv) =>
-    yargs
-      .option("path", {
-        type: "string",
-        describe: "directory path to generate the agent file",
-      })
-      .option("description", {
-        type: "string",
-        describe: "what the agent should do",
-      })
-      .option("mode", {
-        type: "string",
-        describe: "agent mode",
-        choices: ["all", "primary", "subagent"] as const,
-      })
-      .option("permissions", {
-        type: "string",
-        alias: ["tools"],
-        describe: `comma-separated list of permissions to allow (default: all). Available: "${AVAILABLE_PERMISSIONS.join(", ")}"`,
-      })
-      .option("model", {
-        type: "string",
-        alias: ["m"],
-        describe: "model to use in the format of provider/model",
-      }),
-  handler: Effect.fn("Cli.agent.create")(function* (args) {
-    const { InstanceRef } = yield* Effect.promise(() => import("@/effect/instance-ref"))
-    const { Agent } = yield* Effect.promise(() => import("../../agent/agent"))
-    const { Provider } = yield* Effect.promise(() => import("@/provider/provider"))
-    const maybeCtx = yield* InstanceRef
-    if (!maybeCtx) return yield* Effect.die("InstanceRef not provided")
-    const ctx = maybeCtx
-    const agentSvc = yield* Agent.Service
-    const runLocalEffect = <A, E>(effect: Effect.Effect<A, E>) =>
-      Effect.runPromise(effect.pipe(Effect.provideService(InstanceRef, ctx)))
-    yield* Effect.promise(async () => {
-      const cliPath = args.path
-      const cliDescription = args.description
-      const cliMode = args.mode as AgentMode | undefined
-      const perms = args.permissions
-
-      const isFullyNonInteractive = cliPath && cliDescription && cliMode && perms !== undefined
-
-      if (!isFullyNonInteractive) {
-        UI.empty()
-        prompts.intro("Create agent")
-      }
-
-      const project = ctx.project
-
-      // Determine scope/path
-      let targetPath: string
-      if (cliPath) {
-        targetPath = path.join(cliPath, "agents")
-      } else {
-        let scope: "global" | "project" = "global"
-        if (project.vcs === "git") {
-          const scopeResult = await prompts.select({
-            message: "Location",
-            options: [
-              {
-                label: "Current project",
-                value: "project" as const,
-                hint: ctx.worktree,
-              },
-              {
-                label: "Global",
-                value: "global" as const,
-                hint: Global.Path.config,
-              },
-            ],
-          })
-          if (prompts.isCancel(scopeResult)) throw new UI.CancelledError()
-          scope = scopeResult
-        }
-        targetPath = path.join(scope === "global" ? Global.Path.config : path.join(ctx.worktree, ".miaw"), "agents")
-      }
-
-      // Get description
-      let description: string
-      if (cliDescription) {
-        description = cliDescription
-      } else {
-        const query = await prompts.text({
-          message: "Description",
-          placeholder: "What should this agent do?",
-          validate: (x) => (x && x.length > 0 ? undefined : "Required"),
-        })
-        if (prompts.isCancel(query)) throw new UI.CancelledError()
-        description = query
-      }
-
-      // Generate agent
-      const spinner = prompts.spinner()
-      spinner.start("Generating agent configuration...")
-      const model = args.model ? Provider.parseModel(args.model) : undefined
-      const generated = await runLocalEffect(agentSvc.generate({ description, model })).catch((error) => {
-        spinner.stop(`LLM failed to generate agent: ${error.message}`, 1)
-        if (isFullyNonInteractive) process.exit(1)
-        throw new UI.CancelledError()
-      })
-      spinner.stop(`Agent ${generated.identifier} generated`)
-
-      // Select permissions to allow
-      let selected: string[]
-      if (perms !== undefined) {
-        selected = perms ? perms.split(",").map((t) => t.trim()) : AVAILABLE_PERMISSIONS
-      } else {
-        const result = await prompts.multiselect({
-          message: "Select permissions to allow (Space to toggle)",
-          options: AVAILABLE_PERMISSIONS.map((permission) => ({
-            label: permission,
-            value: permission,
-          })),
-          initialValues: AVAILABLE_PERMISSIONS,
-        })
-        if (prompts.isCancel(result)) throw new UI.CancelledError()
-        selected = result
-      }
-
-      // Get mode
-      let mode: AgentMode
-      if (cliMode) {
-        mode = cliMode
-      } else {
-        const modeResult = await prompts.select({
-          message: "Agent mode",
-          options: [
-            {
-              label: "All",
-              value: "all" as const,
-              hint: "Can function in both primary and subagent roles",
-            },
-            {
-              label: "Primary",
-              value: "primary" as const,
-              hint: "Acts as a primary/main agent",
-            },
-            {
-              label: "Subagent",
-              value: "subagent" as const,
-              hint: "Can be used as a subagent by other agents",
-            },
-          ],
-          initialValue: "all" as const,
-        })
-        if (prompts.isCancel(modeResult)) throw new UI.CancelledError()
-        mode = modeResult
-      }
-
-      // Build permissions config — deny anything not explicitly selected.
-      const permissions: Record<string, "deny"> = {}
-      for (const permission of AVAILABLE_PERMISSIONS) {
-        if (!selected.includes(permission)) {
-          permissions[permission] = "deny"
-        }
-      }
-
-      // Build frontmatter
-      const frontmatter: {
-        description: string
-        mode: AgentMode
-        permission?: Record<string, "deny">
-      } = {
-        description: generated.whenToUse,
-        mode,
-      }
-      if (Object.keys(permissions).length > 0) {
-        frontmatter.permission = permissions
-      }
-
-      // Write file
-      const content = matter.stringify(generated.systemPrompt, frontmatter)
-      const filePath = path.join(targetPath, `${generated.identifier}.md`)
-
-      await fs.mkdir(targetPath, { recursive: true })
-
-      if (await Filesystem.exists(filePath)) {
-        if (isFullyNonInteractive) {
-          console.error(`Error: Agent file already exists: ${filePath}`)
-          process.exit(1)
-        }
-        prompts.log.error(`Agent file already exists: ${filePath}`)
-        throw new UI.CancelledError()
-      }
-
-      await Filesystem.write(filePath, content)
-
-      if (isFullyNonInteractive) {
-        console.log(filePath)
-      } else {
-        prompts.log.success(`Agent created: ${filePath}`)
-        prompts.outro("Done")
-      }
-    })
-  }),
-})
-
-const AgentListCommand = effectCmd({
-  command: "list",
-  describe: "list all available agents",
-  handler: Effect.fn("Cli.agent.list")(function* () {
-    const { Agent } = yield* Effect.promise(() => import("../../agent/agent"))
-    const agents = yield* Agent.Service.use((svc) => svc.list())
-
-    for (const agent of agents) {
-      process.stdout.write(`${agent.name} (${agent.mode})` + EOL)
-      process.stdout.write(`  ${JSON.stringify(agent.permission, null, 2)}` + EOL)
-    }
-  }),
-})
-
-export const AgentCommand = cmd({
-  command: "agent",
-  describe: "manage agents",
-  builder: (yargs) => yargs.command(AgentCreateCommand).command(AgentListCommand).demandCommand(),
-  async handler() {},
-})

package/src/cli/cmd/attach.ts

@@ -1,97 +0,0 @@
-import { cmd } from "./cmd"
-import { UI } from "@/cli/ui"
-import { errorMessage } from "@miaw/tui/util/error"
-import { validateSession } from "../tui/validate-session"
-import { ServerAuth } from "@/server/auth"
-
-export const AttachCommand = cmd({
-  command: "attach <url>",
-  describe: "attach to a running miaw server",
-  builder: (yargs) =>
-    yargs
-      .positional("url", {
-        type: "string",
-        describe: "http://localhost:4096",
-        demandOption: true,
-      })
-      .option("dir", {
-        type: "string",
-        description: "directory to run in",
-      })
-      .option("continue", {
-        alias: ["c"],
-        describe: "continue the last session",
-        type: "boolean",
-      })
-      .option("session", {
-        alias: ["s"],
-        type: "string",
-        describe: "session id to continue",
-      })
-      .option("fork", {
-        type: "boolean",
-        describe: "fork the session when continuing (use with --continue or --session)",
-      })
-      .option("password", {
-        alias: ["p"],
-        type: "string",
-        describe: "basic auth password (defaults to MIAW_SERVER_PASSWORD)",
-      })
-      .option("username", {
-        alias: ["u"],
-        type: "string",
-        describe: "basic auth username (defaults to MIAW_SERVER_USERNAME or 'miaw')",
-      }),
-  handler: async (args) => {
-    const { TuiConfig } = await import("@/config/tui")
-    if (args.fork && !args.continue && !args.session) {
-      UI.error("--fork requires --continue or --session")
-      process.exitCode = 1
-      return
-    }
-
-    const directory = (() => {
-      if (!args.dir) return undefined
-      try {
-        process.chdir(args.dir)
-        return process.cwd()
-      } catch {
-        // If the directory doesn't exist locally (remote attach), pass it through.
-        return args.dir
-      }
-    })()
-    const headers = ServerAuth.headers({ password: args.password, username: args.username })
-    const config = await TuiConfig.get()
-
-    try {
-      await validateSession({
-        url: args.url,
-        sessionID: args.session,
-        directory,
-        headers,
-      })
-    } catch (error) {
-      UI.error(errorMessage(error))
-      process.exitCode = 1
-      return
-    }
-
-    const { Effect } = await import("effect")
-    const { run } = await import("../tui/layer")
-    const { createLegacyTuiPluginHost } = await import("@/plugin/tui/runtime")
-    await Effect.runPromise(
-      run({
-        url: args.url,
-        config,
-        pluginHost: createLegacyTuiPluginHost(),
-        args: {
-          continue: args.continue,
-          sessionID: args.session,
-          fork: args.fork,
-        },
-        directory,
-        headers,
-      }),
-    )
-  },
-})

package/src/cli/cmd/cmd.ts

@@ -1,7 +0,0 @@
-import type { CommandModule } from "yargs"
-
-export type WithDoubleDash<T> = T & { "--"?: string[] }
-
-export function cmd<T, U>(input: CommandModule<T, WithDoubleDash<U>>) {
-  return input
-}

package/src/cli/cmd/db.ts

@@ -1,62 +0,0 @@
-import type { Argv } from "yargs"
-import { spawn } from "child_process"
-import { Database } from "@miaw/core/database/database"
-import { Effect } from "effect"
-import { sql } from "drizzle-orm"
-import { effectCmd } from "../effect-cmd"
-
-const QueryCommand = effectCmd({
-  command: "$0 [query]",
-  describe: "open an interactive sqlite3 shell or run a query",
-  instance: false,
-  builder: (yargs: Argv) => {
-    return yargs
-      .positional("query", {
-        type: "string",
-        describe: "SQL query to execute",
-      })
-      .option("format", {
-        type: "string",
-        choices: ["json", "tsv"],
-        default: "tsv",
-        describe: "Output format",
-      })
-  },
-  handler: Effect.fn("Cli.db.query")(function* (args: { query?: string; format: string }) {
-    const query = args.query as string | undefined
-    if (query) {
-      const { db } = yield* Database.Service
-      const result = yield* db.all<Record<string, unknown>>(sql.raw(query)).pipe(Effect.orDie)
-      if (args.format === "json") console.log(JSON.stringify(result, null, 2))
-      else if (result.length > 0) {
-        const keys = Object.keys(result[0])
-        console.log(keys.join("\t"))
-        for (const row of result) console.log(keys.map((key) => row[key]).join("\t"))
-      }
-      return
-    }
-    const child = spawn("sqlite3", [Database.path()], {
-      stdio: "inherit",
-    })
-    yield* Effect.promise(() => new Promise((resolve) => child.on("close", resolve)))
-  }),
-})
-
-const PathCommand = effectCmd({
-  command: "path",
-  describe: "print the database path",
-  instance: false,
-  handler: Effect.fn("Cli.db.path")(function* () {
-    console.log(Database.path())
-  }),
-})
-
-export const DbCommand = effectCmd({
-  command: "db",
-  describe: "database tools",
-  instance: false,
-  builder: (yargs: Argv) => {
-    return yargs.command(QueryCommand).command(PathCommand).demandCommand()
-  },
-  handler: Effect.fn("Cli.db")(function* () {}),
-})

package/src/cli/cmd/debug/agent.handler.ts

@@ -1,193 +0,0 @@
-import { PermissionV1 } from "@miaw/core/v1/permission"
-import { EOL } from "os"
-import { SessionV1 } from "@miaw/core/v1/session"
-import { basename } from "path"
-import { Cause, Effect } from "effect"
-import { Agent } from "../../../agent/agent"
-import { Provider } from "@/provider/provider"
-import { Session } from "@/session/session"
-import type { MessageV2 } from "../../../session/message-v2"
-import { MessageID, PartID } from "../../../session/schema"
-import { ToolRegistry } from "@/tool/registry"
-import { Permission } from "../../../permission"
-import { iife } from "../../../util/iife"
-import { fail } from "../../effect-cmd"
-import { InstanceRef } from "@/effect/instance-ref"
-import type { InstanceContext } from "@/project/instance-context"
-
-export const debugAgent = Effect.fn("Cli.debug.agent")(function* (args: {
-  name: string
-  tool?: string
-  params?: string
-}) {
-  const ctx = yield* InstanceRef
-  if (!ctx) return
-  return yield* run(args, ctx)
-})
-
-const run = Effect.fn("Cli.debug.agent.body")(function* (
-  args: { name: string; tool?: string; params?: string },
-  ctx: InstanceContext,
-) {
-  const agentName = args.name
-  const agent = yield* Agent.Service.use((svc) => svc.get(agentName))
-  if (!agent) {
-    process.stderr.write(
-      `Agent ${agentName} not found, run '${basename(process.execPath)} agent list' to get an agent list` + EOL,
-    )
-    return yield* fail("", 1)
-  }
-  const availableTools = yield* getAvailableTools(agent)
-  const resolvedTools = resolveTools(agent, availableTools)
-  const toolID = args.tool
-  if (toolID) {
-    const tool = availableTools.find((item) => item.id === toolID)
-    if (!tool) {
-      process.stderr.write(`Tool ${toolID} not found for agent ${agentName}` + EOL)
-      return yield* fail("", 1)
-    }
-    if (resolvedTools[toolID] === false) {
-      process.stderr.write(`Tool ${toolID} is disabled for agent ${agentName}` + EOL)
-      return yield* fail("", 1)
-    }
-    const params = parseToolParams(args.params)
-    const toolCtx = yield* createToolContext(agent, ctx)
-    const result = yield* tool.execute(params, toolCtx)
-    process.stdout.write(JSON.stringify({ tool: toolID, input: params, result }, null, 2) + EOL)
-    return
-  }
-
-  const output = {
-    ...agent,
-    tools: resolvedTools,
-  }
-  process.stdout.write(JSON.stringify(output, null, 2) + EOL)
-})
-
-const getAvailableTools = Effect.fn("Cli.debug.agent.getAvailableTools")(function* (agent: Agent.Info) {
-  const provider = yield* Provider.Service
-  const registry = yield* ToolRegistry.Service
-  const model =
-    agent.model ??
-    (yield* provider.defaultModel().pipe(
-      Effect.matchCauseEffect({
-        onSuccess: Effect.succeed,
-        onFailure: (cause) => {
-          const error = Cause.squash(cause) as Provider.DefaultModelError
-          if (error instanceof Provider.ModelNotFoundError) {
-            return fail(`Model not found: ${error.providerID}/${error.modelID}`)
-          }
-          if (error instanceof Provider.NoModelsError) return fail(`No models found for provider ${error.providerID}`)
-          return fail("No providers found")
-        },
-      }),
-    ))
-  return yield* registry.tools({ ...model, agent })
-})
-
-function resolveTools(agent: Agent.Info, availableTools: { id: string }[]) {
-  const disabled = Permission.disabled(
-    availableTools.map((tool) => tool.id),
-    agent.permission,
-  )
-  const resolved: Record<string, boolean> = {}
-  for (const tool of availableTools) {
-    resolved[tool.id] = !disabled.has(tool.id)
-  }
-  return resolved
-}
-
-function parseToolParams(input?: string) {
-  if (!input) return {}
-  const trimmed = input.trim()
-  if (trimmed.length === 0) return {}
-
-  const parsed = iife(() => {
-    try {
-      return JSON.parse(trimmed)
-    } catch (jsonError) {
-      try {
-        return new Function(`return (${trimmed})`)()
-      } catch (evalError) {
-        throw new Error(
-          `Failed to parse --params. Use JSON or a JS object literal. JSON error: ${jsonError}. Eval error: ${evalError}.`,
-          { cause: evalError },
-        )
-      }
-    }
-  })
-
-  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
-    throw new Error("Tool params must be an object.")
-  }
-  return parsed as Record<string, unknown>
-}
-
-const createToolContext = Effect.fn("Cli.debug.agent.createToolContext")(function* (
-  agent: Agent.Info,
-  ctx: InstanceContext,
-) {
-  const sessionSvc = yield* Session.Service
-  const session = yield* sessionSvc.create({ title: `Debug tool run (${agent.name})` })
-  const messageID = MessageID.ascending()
-  const model = agent.model
-    ? agent.model
-    : yield* Effect.gen(function* () {
-        const provider = yield* Provider.Service
-        return yield* provider.defaultModel().pipe(
-          Effect.matchCauseEffect({
-            onSuccess: Effect.succeed,
-            onFailure: (cause) => {
-              const error = Cause.squash(cause) as Provider.DefaultModelError
-              if (error instanceof Provider.ModelNotFoundError) {
-                return fail(`Model not found: ${error.providerID}/${error.modelID}`)
-              }
-              if (error instanceof Provider.NoModelsError)
-                return fail(`No models found for provider ${error.providerID}`)
-              return fail("No providers found")
-            },
-          }),
-        )
-      })
-  const now = Date.now()
-  const message: SessionV1.Assistant = {
-    id: messageID,
-    sessionID: session.id,
-    role: "assistant",
-    time: { created: now },
-    parentID: messageID,
-    modelID: model.modelID,
-    providerID: model.providerID,
-    mode: "debug",
-    agent: agent.name,
-    path: {
-      cwd: ctx.directory,
-      root: ctx.worktree,
-    },
-    cost: 0,
-    tokens: { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } },
-  }
-  yield* sessionSvc.updateMessage(message)
-
-  const ruleset = Permission.merge(agent.permission, session.permission ?? [])
-
-  return {
-    sessionID: session.id,
-    messageID,
-    callID: PartID.ascending(),
-    agent: agent.name,
-    abort: new AbortController().signal,
-    messages: [],
-    metadata: () => Effect.void,
-    ask(req: Omit<PermissionV1.Request, "id" | "sessionID" | "tool">) {
-      return Effect.sync(() => {
-        for (const pattern of req.patterns) {
-          const rule = Permission.evaluate(req.permission, pattern, ruleset)
-          if (rule.action === "deny") {
-            throw new PermissionV1.DeniedError({ ruleset })
-          }
-        }
-      })
-    },
-  }
-})