nikcli 0.0.6

package/src/permission/arity.ts

@@ -0,0 +1,150 @@
+export namespace BashArity {
+  export function prefix(tokens: string[]) {
+    for (let len = tokens.length; len > 0; len--) {
+      const prefix = tokens.slice(0, len).join(" ")
+      const arity = ARITY[prefix]
+      if (arity !== undefined) return tokens.slice(0, arity)
+    }
+    if (tokens.length === 0) return []
+    return tokens.slice(0, 1)
+  }
+
+  const ARITY: Record<string, number> = {
+    cat: 1,
+    cd: 1,
+    chmod: 1,
+    chown: 1,
+    cp: 1,
+    echo: 1,
+    env: 1,
+    export: 1,
+    grep: 1,
+    kill: 1,
+    killall: 1,
+    ln: 1,
+    ls: 1,
+    mkdir: 1,
+    mv: 1,
+    ps: 1,
+    pwd: 1,
+    rm: 1,
+    rmdir: 1,
+    sleep: 1,
+    source: 1,
+    tail: 1,
+    touch: 1,
+    unset: 1,
+    which: 1,
+    aws: 3,
+    az: 3,
+    bazel: 2,
+    brew: 2,
+    bun: 2,
+    "bun run": 3,
+    "bun x": 3,
+    cargo: 2,
+    "cargo add": 3,
+    "cargo run": 3,
+    cdk: 2,
+    cf: 2,
+    cmake: 2,
+    composer: 2,
+    consul: 2,
+    "consul kv": 3,
+    crictl: 2,
+    deno: 2,
+    "deno task": 3,
+    doctl: 3,
+    docker: 2,
+    "docker builder": 3,
+    "docker compose": 3,
+    "docker container": 3,
+    "docker image": 3,
+    "docker network": 3,
+    "docker volume": 3,
+    eksctl: 2,
+    "eksctl create": 3,
+    firebase: 2,
+    flyctl: 2,
+    gcloud: 3,
+    gh: 3,
+    git: 2,
+    "git config": 3,
+    "git remote": 3,
+    "git stash": 3,
+    go: 2,
+    gradle: 2,
+    helm: 2,
+    heroku: 2,
+    hugo: 2,
+    ip: 2,
+    "ip addr": 3,
+    "ip link": 3,
+    "ip netns": 3,
+    "ip route": 3,
+    kind: 2,
+    "kind create": 3,
+    kubectl: 2,
+    "kubectl kustomize": 3,
+    "kubectl rollout": 3,
+    kustomize: 2,
+    make: 2,
+    mc: 2,
+    "mc admin": 3,
+    minikube: 2,
+    mongosh: 2,
+    mysql: 2,
+    mvn: 2,
+    ng: 2,
+    npm: 2,
+    "npm exec": 3,
+    "npm init": 3,
+    "npm run": 3,
+    "npm view": 3,
+    nvm: 2,
+    nx: 2,
+    openssl: 2,
+    "openssl req": 3,
+    "openssl x509": 3,
+    pip: 2,
+    pipenv: 2,
+    pnpm: 2,
+    "pnpm dlx": 3,
+    "pnpm exec": 3,
+    "pnpm run": 3,
+    poetry: 2,
+    podman: 2,
+    "podman container": 3,
+    "podman image": 3,
+    psql: 2,
+    pulumi: 2,
+    "pulumi stack": 3,
+    pyenv: 2,
+    python: 2,
+    rake: 2,
+    rbenv: 2,
+    "redis-cli": 2,
+    rustup: 2,
+    serverless: 2,
+    sfdx: 3,
+    skaffold: 2,
+    sls: 2,
+    sst: 2,
+    swift: 2,
+    systemctl: 2,
+    terraform: 2,
+    "terraform workspace": 3,
+    tmux: 2,
+    turbo: 2,
+    ufw: 2,
+    vault: 2,
+    "vault auth": 3,
+    "vault kv": 3,
+    vercel: 2,
+    volta: 2,
+    wp: 2,
+    yarn: 2,
+    "yarn dlx": 3,
+    "yarn run": 3,
+  }
+}

package/src/permission/dbedit.ts

@@ -0,0 +1,236 @@
+import { Bus } from "@/bus"
+import { BusEvent } from "@/bus/bus-event"
+import { Instance } from "@/project/instance"
+import { Storage } from "@/storage/storage"
+import { fn } from "@/util/fn"
+import { Log } from "@/util/log"
+import { Identifier } from "@/id/id"
+import z from "zod"
+import type { DBEditRequest } from "../cli/cmd/tui/component/table-db/db/types"
+
+export namespace DBEditNext {
+  const log = Log.create({ service: "dbedit" })
+
+  export const Request = z
+    .object({
+      id: Identifier.schema("dbedit"),
+      sessionID: Identifier.schema("session"),
+      type: z.enum(["db_create", "db_edit", "db_query"]),
+      filePath: z.string(),
+      schema: z
+        .object({
+          tables: z.array(
+            z.object({
+              name: z.string(),
+              columns: z.array(
+                z.object({
+                  name: z.string(),
+                  type: z.string(),
+                  notNull: z.boolean(),
+                  defaultValue: z.string().optional(),
+                  primaryKey: z.boolean(),
+                }),
+              ),
+              primaryKey: z.string().array(),
+              foreignKeys: z
+                .array(
+                  z.object({
+                    table: z.string(),
+                    column: z.string(),
+                    referencedTable: z.string(),
+                    referencedColumn: z.string(),
+                    onDelete: z.enum(["CASCADE", "RESTRICT", "SET NULL", "NO ACTION"]),
+                  }),
+                )
+                .optional(),
+              rowCount: z.number().optional(),
+              sql: z.string().optional(),
+            }),
+          ),
+          views: z
+            .array(
+              z.object({
+                name: z.string(),
+                sql: z.string(),
+              }),
+            )
+            .optional(),
+          indexes: z
+            .array(
+              z.object({
+                name: z.string(),
+                tableName: z.string(),
+                columns: z.string().array(),
+                unique: z.boolean(),
+              }),
+            )
+            .optional(),
+        })
+        .optional(),
+      preview: z
+        .array(
+          z.object({
+            tableName: z.string(),
+            columns: z.array(
+              z.object({
+                name: z.string(),
+                type: z.string(),
+                notNull: z.boolean(),
+                defaultValue: z.string().optional(),
+                primaryKey: z.boolean(),
+              }),
+            ),
+            sampleData: z.array(z.record(z.string(), z.any())),
+            rowCount: z.number(),
+          }),
+        )
+        .optional(),
+      changes: z
+        .array(
+          z.object({
+            type: z.enum(["add_table", "drop_table", "add_column", "drop_column", "modify_column"]),
+            tableName: z.string(),
+            columnName: z.string().optional(),
+            oldDefinition: z
+              .object({
+                name: z.string(),
+                type: z.string(),
+                notNull: z.boolean(),
+                defaultValue: z.string().optional(),
+                primaryKey: z.boolean(),
+              })
+              .optional(),
+            newDefinition: z
+              .object({
+                name: z.string(),
+                type: z.string(),
+                notNull: z.boolean(),
+                defaultValue: z.string().optional(),
+                primaryKey: z.boolean(),
+              })
+              .optional(),
+          }),
+        )
+        .optional(),
+      sql: z.string().optional(),
+      always: z.string().array(),
+      tool: z
+        .object({
+          messageID: z.string(),
+          callID: z.string(),
+        })
+        .optional(),
+    })
+    .meta({
+      ref: "DBEditRequest",
+    })
+
+  export type Request = DBEditRequest
+
+  export const Reply = z.enum(["accept", "edit", "reject"])
+  export type Reply = z.infer<typeof Reply>
+
+  export const Event = {
+    Asked: BusEvent.define("dbedit.asked", Request),
+    Replied: BusEvent.define(
+      "dbedit.replied",
+      z.object({
+        sessionID: z.string(),
+        requestID: z.string(),
+        reply: Reply,
+      }),
+    ),
+  }
+
+  const state = Instance.state(async () => {
+    const projectID = Instance.project.id
+    return {
+      pending: {} as Record<
+        string,
+        {
+          info: Request
+          resolve: (modified?: Request) => void
+          reject: (e: any) => void
+        }
+      >,
+    }
+  })
+
+  export const ask = fn(Request.partial({ id: true }), async (input) => {
+    const s = await state()
+    const id = input.id ?? Identifier.ascending("dbedit")
+
+    return new Promise<Request | undefined>((resolve, reject) => {
+      const info: Request = {
+        id,
+        ...input,
+      }
+      s.pending[id] = {
+        info,
+        resolve: (modified) => resolve(modified ?? info),
+        reject,
+      }
+      Bus.publish(Event.Asked, info)
+    })
+  })
+
+  export const reply = fn(
+    z.object({
+      requestID: Identifier.schema("dbedit"),
+      reply: Reply,
+      modified: Request.optional(),
+      message: z.string().optional(),
+    }),
+    async (input) => {
+      const s = await state()
+      const existing = s.pending[input.requestID]
+      if (!existing) return
+
+      delete s.pending[input.requestID]
+
+      if (input.reply === "reject") {
+        Bus.publish(Event.Replied, {
+          sessionID: existing.info.sessionID,
+          requestID: existing.info.id,
+          reply: "reject",
+        })
+        existing.reject(new RejectedError(input.message))
+        return
+      }
+
+      if (input.reply === "accept") {
+        Bus.publish(Event.Replied, {
+          sessionID: existing.info.sessionID,
+          requestID: existing.info.id,
+          reply: "accept",
+        })
+        existing.resolve()
+        return
+      }
+
+      if (input.reply === "edit" && input.modified) {
+        Bus.publish(Event.Replied, {
+          sessionID: existing.info.sessionID,
+          requestID: existing.info.id,
+          reply: "edit",
+        })
+        existing.resolve(input.modified)
+        return
+      }
+    },
+  )
+
+  export async function list() {
+    return state().then((x) => Object.values(x.pending).map((x) => x.info))
+  }
+
+  export class RejectedError extends Error {
+    constructor(message?: string) {
+      super(
+        message
+          ? `The user rejected database changes with feedback: ${message}`
+          : `The user rejected the database changes.`,
+      )
+    }
+  }
+}

package/src/permission/index.ts

@@ -0,0 +1,210 @@
+import { BusEvent } from "@/bus/bus-event"
+import { Bus } from "@/bus"
+import z from "zod"
+import { Log } from "../util/log"
+import { Identifier } from "../id/id"
+import { Plugin } from "../plugin"
+import { Instance } from "../project/instance"
+import { Wildcard } from "../util/wildcard"
+
+export namespace Permission {
+  const log = Log.create({ service: "permission" })
+
+  function toKeys(pattern: Info["pattern"], type: string): string[] {
+    return pattern === undefined ? [type] : Array.isArray(pattern) ? pattern : [pattern]
+  }
+
+  function covered(keys: string[], approved: Record<string, boolean>): boolean {
+    const pats = Object.keys(approved)
+    return keys.every((k) => pats.some((p) => Wildcard.match(k, p)))
+  }
+
+  export const Info = z
+    .object({
+      id: z.string(),
+      type: z.string(),
+      pattern: z.union([z.string(), z.array(z.string())]).optional(),
+      sessionID: z.string(),
+      messageID: z.string(),
+      callID: z.string().optional(),
+      message: z.string(),
+      metadata: z.record(z.string(), z.any()),
+      time: z.object({
+        created: z.number(),
+      }),
+    })
+    .meta({
+      ref: "Permission",
+    })
+  export type Info = z.infer<typeof Info>
+
+  export const Event = {
+    Updated: BusEvent.define("permission.updated", Info),
+    Replied: BusEvent.define(
+      "permission.replied",
+      z.object({
+        sessionID: z.string(),
+        permissionID: z.string(),
+        response: z.string(),
+      }),
+    ),
+  }
+
+  const state = Instance.state(
+    () => {
+      const pending: {
+        [sessionID: string]: {
+          [permissionID: string]: {
+            info: Info
+            resolve: () => void
+            reject: (e: any) => void
+          }
+        }
+      } = {}
+
+      const approved: {
+        [sessionID: string]: {
+          [permissionID: string]: boolean
+        }
+      } = {}
+
+      return {
+        pending,
+        approved,
+      }
+    },
+    async (state) => {
+      for (const pending of Object.values(state.pending)) {
+        for (const item of Object.values(pending)) {
+          item.reject(new RejectedError(item.info.sessionID, item.info.id, item.info.callID, item.info.metadata))
+        }
+      }
+    },
+  )
+
+  export function pending() {
+    return state().pending
+  }
+
+  export function list() {
+    const { pending } = state()
+    const result: Info[] = []
+    for (const items of Object.values(pending)) {
+      for (const item of Object.values(items)) {
+        result.push(item.info)
+      }
+    }
+    return result.sort((a, b) => a.id.localeCompare(b.id))
+  }
+
+  export async function ask(input: {
+    type: Info["type"]
+    message: Info["message"]
+    pattern?: Info["pattern"]
+    callID?: Info["callID"]
+    sessionID: Info["sessionID"]
+    messageID: Info["messageID"]
+    metadata: Info["metadata"]
+  }) {
+    const { pending, approved } = state()
+    log.info("asking", {
+      sessionID: input.sessionID,
+      messageID: input.messageID,
+      toolCallID: input.callID,
+      pattern: input.pattern,
+    })
+    const approvedForSession = approved[input.sessionID] || {}
+    const keys = toKeys(input.pattern, input.type)
+    if (covered(keys, approvedForSession)) return
+    const info: Info = {
+      id: Identifier.ascending("permission"),
+      type: input.type,
+      pattern: input.pattern,
+      sessionID: input.sessionID,
+      messageID: input.messageID,
+      callID: input.callID,
+      message: input.message,
+      metadata: input.metadata,
+      time: {
+        created: Date.now(),
+      },
+    }
+
+    switch (
+      await Plugin.trigger("permission.ask", info, {
+        status: "ask",
+      }).then((x) => x.status)
+    ) {
+      case "deny":
+        throw new RejectedError(info.sessionID, info.id, info.callID, info.metadata)
+      case "allow":
+        return
+    }
+
+    pending[input.sessionID] = pending[input.sessionID] || {}
+    return new Promise<void>((resolve, reject) => {
+      pending[input.sessionID][info.id] = {
+        info,
+        resolve,
+        reject,
+      }
+      Bus.publish(Event.Updated, info)
+    })
+  }
+
+  export const Response = z.enum(["once", "always", "reject"])
+  export type Response = z.infer<typeof Response>
+
+  export function respond(input: { sessionID: Info["sessionID"]; permissionID: Info["id"]; response: Response }) {
+    log.info("response", input)
+    const { pending, approved } = state()
+    const match = pending[input.sessionID]?.[input.permissionID]
+    if (!match) return
+    delete pending[input.sessionID][input.permissionID]
+    Bus.publish(Event.Replied, {
+      sessionID: input.sessionID,
+      permissionID: input.permissionID,
+      response: input.response,
+    })
+    if (input.response === "reject") {
+      match.reject(new RejectedError(input.sessionID, input.permissionID, match.info.callID, match.info.metadata))
+      return
+    }
+    match.resolve()
+    if (input.response === "always") {
+      approved[input.sessionID] = approved[input.sessionID] || {}
+      const approveKeys = toKeys(match.info.pattern, match.info.type)
+      for (const k of approveKeys) {
+        approved[input.sessionID][k] = true
+      }
+      const items = pending[input.sessionID]
+      if (!items) return
+      for (const item of Object.values(items)) {
+        const itemKeys = toKeys(item.info.pattern, item.info.type)
+        if (covered(itemKeys, approved[input.sessionID])) {
+          respond({
+            sessionID: item.info.sessionID,
+            permissionID: item.info.id,
+            response: input.response,
+          })
+        }
+      }
+    }
+  }
+
+  export class RejectedError extends Error {
+    constructor(
+      public readonly sessionID: string,
+      public readonly permissionID: string,
+      public readonly toolCallID?: string,
+      public readonly metadata?: Record<string, any>,
+      public readonly reason?: string,
+    ) {
+      super(
+        reason !== undefined
+          ? reason
+          : `The user rejected permission to use this specific tool call. You may try again with different parameters.`,
+      )
+    }
+  }
+}