nikcli 0.0.6

package/src/util/wildcard.ts

@@ -0,0 +1,56 @@
+import { sortBy, pipe } from "remeda"
+
+export namespace Wildcard {
+  export function match(str: string, pattern: string) {
+    let escaped = pattern
+      .replace(/[.+^${}()|[\]\\]/g, "\\$&") // escape special regex chars
+      .replace(/\*/g, ".*") // * becomes .*
+      .replace(/\?/g, ".") // ? becomes .
+
+    // If pattern ends with " *" (space + wildcard), make the trailing part optional
+    // This allows "ls *" to match both "ls" and "ls -la"
+    if (escaped.endsWith(" .*")) {
+      escaped = escaped.slice(0, -3) + "( .*)?"
+    }
+
+    return new RegExp("^" + escaped + "$", "s").test(str)
+  }
+
+  export function all(input: string, patterns: Record<string, any>) {
+    const sorted = pipe(patterns, Object.entries, sortBy([([key]) => key.length, "asc"], [([key]) => key, "asc"]))
+    let result = undefined
+    for (const [pattern, value] of sorted) {
+      if (match(input, pattern)) {
+        result = value
+        continue
+      }
+    }
+    return result
+  }
+
+  export function allStructured(input: { head: string; tail: string[] }, patterns: Record<string, any>) {
+    const sorted = pipe(patterns, Object.entries, sortBy([([key]) => key.length, "asc"], [([key]) => key, "asc"]))
+    let result = undefined
+    for (const [pattern, value] of sorted) {
+      const parts = pattern.split(/\s+/)
+      if (!match(input.head, parts[0])) continue
+      if (parts.length === 1 || matchSequence(input.tail, parts.slice(1))) {
+        result = value
+        continue
+      }
+    }
+    return result
+  }
+
+  function matchSequence(items: string[], patterns: string[]): boolean {
+    if (patterns.length === 0) return true
+    const [pattern, ...rest] = patterns
+    if (pattern === "*") return matchSequence(items, rest)
+    for (let i = 0; i < items.length; i++) {
+      if (match(items[i], pattern) && matchSequence(items.slice(i + 1), rest)) {
+        return true
+      }
+    }
+    return false
+  }
+}

package/src/workspace/adaptors/index.ts

@@ -0,0 +1,271 @@
+import fs from "fs/promises"
+import path from "path"
+import { createServer } from "node:net"
+import { fileURLToPath } from "node:url"
+import { Global } from "@/global"
+import type { Config } from "../config"
+import type { Adaptor } from "./types"
+import { WorktreeAdaptor } from "./worktree"
+
+type ContainerConfig = Extract<Config, { type: "container" }>
+
+const CONFIGURED_CONTAINER_IMAGE = process.env.NIKCLI_MOBILE_CONTAINER_IMAGE?.trim()
+const LOCAL_CONTAINER_IMAGE = "nikcli-mobile-workspace:local"
+const LOCAL_CONTAINER_DOCKERFILE = fileURLToPath(new URL("../../../../../Dockerfile.serve", import.meta.url))
+const LOCAL_CONTAINER_CONTEXT = path.dirname(LOCAL_CONTAINER_DOCKERFILE)
+
+type ContainerImageSource =
+  | {
+      image: string
+      source: "configured"
+    }
+  | {
+      image: string
+      source: "local-build"
+      dockerfile: string
+      context: string
+    }
+
+type ContainerRuntimeInfo = {
+  available: boolean
+  runtime?: ContainerConfig["runtime"]
+  image: string
+}
+
+async function hasLocalContainerBuildContext() {
+  return fs
+    .stat(LOCAL_CONTAINER_DOCKERFILE)
+    .then((entry) => entry.isFile())
+    .catch(() => false)
+}
+
+async function resolveContainerImageSource(): Promise<ContainerImageSource | undefined> {
+  if (CONFIGURED_CONTAINER_IMAGE) {
+    return {
+      image: CONFIGURED_CONTAINER_IMAGE,
+      source: "configured",
+    }
+  }
+
+  if (await hasLocalContainerBuildContext()) {
+    return {
+      image: LOCAL_CONTAINER_IMAGE,
+      source: "local-build",
+      dockerfile: LOCAL_CONTAINER_DOCKERFILE,
+      context: LOCAL_CONTAINER_CONTEXT,
+    }
+  }
+
+  return undefined
+}
+
+function containerRuntime(): ContainerConfig["runtime"] | undefined {
+  if (Bun.which("docker")) return "docker"
+  if (Bun.which("podman")) return "podman"
+  return undefined
+}
+
+async function isRuntimeHealthy(runtime: ContainerConfig["runtime"]) {
+  const result = await runContainerCommand(runtime, ["info"], true)
+  return result.exitCode === 0
+}
+
+async function ensureContainerImage(runtime: ContainerConfig["runtime"], source: ContainerImageSource) {
+  if (source.source === "configured") return source.image
+
+  const inspect = await runContainerCommand(runtime, ["image", "inspect", source.image], true)
+  if (inspect.exitCode === 0) return source.image
+
+  await runContainerCommand(runtime, ["build", "-f", source.dockerfile, "-t", source.image, source.context])
+  return source.image
+}
+
+export async function getContainerRuntimeInfo(): Promise<ContainerRuntimeInfo> {
+  const runtime = containerRuntime()
+  const imageSource = await resolveContainerImageSource()
+
+  if (!runtime) {
+    return {
+      available: false,
+      runtime: undefined,
+      image: imageSource?.image ?? LOCAL_CONTAINER_IMAGE,
+    }
+  }
+
+  const healthy = await isRuntimeHealthy(runtime)
+
+  return {
+    available: healthy && Boolean(imageSource),
+    runtime,
+    image: imageSource?.image ?? LOCAL_CONTAINER_IMAGE,
+  }
+}
+
+async function reservePort(): Promise<number> {
+  return new Promise((resolve, reject) => {
+    const server = createServer()
+    server.unref()
+    server.once("error", reject)
+    server.listen(0, "127.0.0.1", () => {
+      const address = server.address()
+      if (!address || typeof address === "string") {
+        server.close()
+        reject(new Error("Failed to reserve container workspace port"))
+        return
+      }
+      server.close((error) => {
+        if (error) {
+          reject(error)
+          return
+        }
+        resolve(address.port)
+      })
+    })
+  })
+}
+
+async function runContainerCommand(runtime: ContainerConfig["runtime"], args: string[], allowFailure = false) {
+  const proc = Bun.spawn([runtime, ...args], {
+    stdout: "pipe",
+    stderr: "pipe",
+  })
+
+  const [exitCode, stdout, stderr] = await Promise.all([
+    proc.exited,
+    new Response(proc.stdout).text(),
+    new Response(proc.stderr).text(),
+  ])
+
+  if (exitCode !== 0 && !allowFailure) {
+    throw new Error(stderr.trim() || stdout.trim() || `${runtime} ${args.join(" ")} failed`)
+  }
+
+  return {
+    exitCode,
+    stdout: stdout.trim(),
+    stderr: stderr.trim(),
+  }
+}
+
+function sanitizeContainerName(input: string) {
+  return input.toLowerCase().replace(/[^a-z0-9_.-]+/g, "-")
+}
+
+async function waitForContainerServer(config: ContainerConfig) {
+  const deadline = Date.now() + 30_000
+  while (Date.now() < deadline) {
+    const controller = new AbortController()
+    const timeout = setTimeout(() => controller.abort(), 1_500)
+    try {
+      const response = await fetch(new URL("/event", config.serverUrl), {
+        headers: {
+          "x-nikcli-directory": config.directory,
+        },
+        signal: controller.signal,
+      })
+      await response.body?.cancel().catch(() => undefined)
+      if (response.ok) return
+    } catch {
+      // wait and retry while the container starts
+    } finally {
+      clearTimeout(timeout)
+    }
+    await Bun.sleep(500)
+  }
+
+  throw new Error(`Workspace container ${config.containerName} did not become ready in time`)
+}
+
+function proxyHeaders(config: ContainerConfig, headers?: HeadersInit) {
+  const next = new Headers(headers)
+  next.delete("host")
+  next.delete("content-length")
+  next.delete("x-nikcli-workspace")
+  if (!next.has("x-nikcli-directory")) next.set("x-nikcli-directory", config.directory)
+  return next
+}
+
+const ContainerAdaptor: Adaptor<ContainerConfig> = {
+  async create(from, _branch, workspaceID) {
+    const runtimeInfo = await getContainerRuntimeInfo()
+    if (!runtimeInfo.available || !runtimeInfo.runtime) {
+      throw new Error(
+        "Container sandbox requires a healthy Docker or Podman runtime and a compatible Nikcli workspace image",
+      )
+    }
+    const runtime = runtimeInfo.runtime
+    const imageSource = await resolveContainerImageSource()
+    if (!imageSource) throw new Error("No Nikcli workspace container image is configured")
+    const image = await ensureContainerImage(runtime, imageSource)
+
+    const port = await reservePort()
+    const containerName = sanitizeContainerName(workspaceID || `nikcli-mobile-${port}`)
+    const config: ContainerConfig = {
+      type: "container",
+      directory: from.directory,
+      runtime,
+      image: from.image || image,
+      containerName,
+      port,
+      serverUrl: `http://127.0.0.1:${port}`,
+    }
+
+    return {
+      config,
+      init: async () => {
+        await runContainerCommand(runtime, ["rm", "-f", containerName], true)
+        await runContainerCommand(runtime, [
+          "run",
+          "-d",
+          "--init",
+          "--name",
+          containerName,
+          "-p",
+          `127.0.0.1:${port}:${port}`,
+          "-v",
+          `${config.directory}:${config.directory}`,
+          "-v",
+          `${Global.Path.data}:${Global.Path.data}`,
+          "-v",
+          `${Global.Path.config}:${Global.Path.config}`,
+          "-v",
+          `${Global.Path.state}:${Global.Path.state}`,
+          "-w",
+          config.directory,
+          config.image,
+          "workspace-serve",
+          "--hostname",
+          "0.0.0.0",
+          "--port",
+          String(port),
+        ])
+        try {
+          await waitForContainerServer(config)
+        } catch (error) {
+          await runContainerCommand(runtime, ["rm", "-f", containerName], true)
+          throw error
+        }
+      },
+    }
+  },
+  async remove(config) {
+    await runContainerCommand(config.runtime, ["rm", "-f", config.containerName], true)
+  },
+  async request(config, method, url, data, signal, headers) {
+    return fetch(new URL(url, config.serverUrl), {
+      method,
+      body: data,
+      headers: proxyHeaders(config, headers),
+      signal,
+    })
+  },
+}
+
+export function getAdaptor(config: Config): Adaptor {
+  switch (config.type) {
+    case "worktree":
+      return WorktreeAdaptor
+    case "container":
+      return ContainerAdaptor
+  }
+}

package/src/workspace/adaptors/types.ts

@@ -0,0 +1,14 @@
+import type { Config } from "../config"
+
+export type Adaptor<T extends Config = Config> = {
+  create(from: T, branch?: string | null, workspaceID?: string): Promise<{ config: T; init: () => Promise<void> }>
+  remove(from: T): Promise<void>
+  request(
+    from: T,
+    method: string,
+    url: string,
+    data?: BodyInit,
+    signal?: AbortSignal,
+    headers?: HeadersInit,
+  ): Promise<Response | undefined>
+}

package/src/workspace/adaptors/worktree.ts

@@ -0,0 +1,31 @@
+import { Worktree } from "@/worktree"
+import type { Config } from "../config"
+import type { Adaptor } from "./types"
+
+type WorktreeConfig = Extract<Config, { type: "worktree" }>
+
+export const WorktreeAdaptor: Adaptor<WorktreeConfig> = {
+  async create(_from: WorktreeConfig, branch: string | null | undefined, _workspaceID?: string) {
+    const next = await Worktree.create(branch ? { branch } : undefined)
+    return {
+      config: {
+        type: "worktree",
+        directory: next.directory,
+      },
+      init: async () => {},
+    }
+  },
+  async remove(config: WorktreeConfig) {
+    await Worktree.remove({ directory: config.directory })
+  },
+  async request(
+    _from: WorktreeConfig,
+    _method: string,
+    _url: string,
+    _data?: BodyInit,
+    _signal?: AbortSignal,
+    _headers?: HeadersInit,
+  ) {
+    throw new Error("worktree does not support request")
+  },
+}

package/src/workspace/config.ts

@@ -0,0 +1,19 @@
+import z from "zod"
+
+export const Config = z.discriminatedUnion("type", [
+  z.object({
+    directory: z.string(),
+    type: z.literal("worktree"),
+  }),
+  z.object({
+    directory: z.string(),
+    type: z.literal("container"),
+    runtime: z.enum(["docker", "podman"]),
+    image: z.string(),
+    containerName: z.string(),
+    port: z.number().int().positive(),
+    serverUrl: z.string().url(),
+  }),
+])
+
+export type Config = z.infer<typeof Config>

package/src/workspace/index.ts

@@ -0,0 +1,223 @@
+import z from "zod"
+import { BusEvent } from "@/bus/bus-event"
+import { GlobalBus } from "@/bus/global"
+import { Identifier } from "@/id/id"
+import { PermissionNext } from "@/permission/next"
+import { Project } from "@/project/project"
+import { InstanceBootstrap } from "@/project/bootstrap"
+import { Instance } from "@/project/instance"
+import { SessionStatus } from "@/session/status"
+import { Storage } from "@/storage/storage"
+import { fn } from "@/util/fn"
+import { Log } from "@/util/log"
+import { getAdaptor } from "./adaptors"
+import { Config } from "./config"
+import { parseSSE } from "./sse"
+
+export namespace Workspace {
+  export const Event = {
+    Ready: BusEvent.define(
+      "workspace.ready",
+      z.object({
+        name: z.string(),
+      }),
+    ),
+    Failed: BusEvent.define(
+      "workspace.failed",
+      z.object({
+        message: z.string(),
+      }),
+    ),
+  }
+
+  export const Info = z
+    .object({
+      id: Identifier.schema("workspace"),
+      branch: z.string().nullable(),
+      projectID: z.string(),
+      config: Config,
+    })
+    .meta({
+      ref: "Workspace",
+    })
+  export type Info = z.infer<typeof Info>
+
+  function fromStorage(row: Partial<Info>): Info {
+    return Info.parse({
+      ...row,
+      branch: row.branch ?? null,
+    })
+  }
+
+  const syncControllers = new Map<string, AbortController>()
+
+  function syncDirectory(space: Info) {
+    if (space.config.type === "worktree") return
+    return space.config.directory
+  }
+
+  async function mirrorWorkspaceEvent(space: Info, event: { type?: string; properties?: any }) {
+    const directory = syncDirectory(space)
+    if (!directory || !event?.type) return
+
+    await Instance.provide({
+      directory,
+      init: InstanceBootstrap,
+      async fn() {
+        if (event.type === "session.status" && event.properties?.sessionID && event.properties?.status) {
+          SessionStatus.hydrate(event.properties.sessionID, event.properties.status)
+        }
+
+        if (event.type === "session.idle" && event.properties?.sessionID) {
+          SessionStatus.hydrate(event.properties.sessionID, { type: "idle" })
+        }
+
+        if (event.type === "permission.asked" && event.properties?.id) {
+          await PermissionNext.hydrateAsk(event.properties)
+        }
+
+        if (event.type === "permission.replied" && event.properties?.requestID) {
+          await PermissionNext.hydrateReply(event.properties.requestID)
+        }
+      },
+    })
+  }
+
+  function startSpaceSync(space: Info) {
+    if (space.config.type === "worktree") return
+    if (syncControllers.has(space.id)) return
+
+    const stop = new AbortController()
+    syncControllers.set(space.id, stop)
+
+    void workspaceEventLoop(space, stop.signal)
+      .catch((error) => {
+        log.warn("workspace sync listener failed", {
+          workspaceID: space.id,
+          error,
+        })
+      })
+      .finally(() => {
+        if (syncControllers.get(space.id) === stop) syncControllers.delete(space.id)
+      })
+  }
+
+  function stopSpaceSync(id: string) {
+    const controller = syncControllers.get(id)
+    if (!controller) return
+    controller.abort()
+    syncControllers.delete(id)
+  }
+
+  export const create = fn(
+    z.object({
+      id: Identifier.schema("workspace").optional(),
+      projectID: Info.shape.projectID,
+      branch: Info.shape.branch,
+      config: Info.shape.config,
+    }),
+    async (input) => {
+      const id = Identifier.ascending("workspace", input.id)
+
+      const { config, init } = await getAdaptor(input.config).create(input.config, input.branch, id)
+
+      const info: Info = {
+        id,
+        projectID: input.projectID,
+        branch: input.branch,
+        config,
+      }
+
+      await init()
+      await Storage.write(["workspace", info.projectID, info.id], info)
+      startSpaceSync(info)
+
+      GlobalBus.emit("event", {
+        directory: id,
+        payload: {
+          type: Event.Ready.type,
+          properties: {},
+        },
+      })
+
+      return info
+    },
+  )
+
+  export async function list(project: Project.Info) {
+    const rows = await Storage.list(["workspace", project.id])
+    const result = await Promise.all(rows.map((row) => Storage.read<Info>(row).catch(() => undefined)))
+    return result
+      .filter((row): row is Info => !!row)
+      .map(fromStorage)
+      .sort((a, b) => a.id.localeCompare(b.id))
+  }
+
+  export const get = fn(Identifier.schema("workspace"), async (id) => {
+    const rows = await Storage.list(["workspace"])
+    for (const row of rows) {
+      const result = await Storage.read<Info>(row).catch(() => undefined)
+      if (!result || result.id !== id) continue
+      return fromStorage(result)
+    }
+    return undefined
+  })
+
+  export const remove = fn(Identifier.schema("workspace"), async (id) => {
+    const info = await get(id)
+    if (info) {
+      stopSpaceSync(id)
+      await getAdaptor(info.config).remove(info.config)
+      await Storage.remove(["workspace", info.projectID, id])
+      return info
+    }
+  })
+  const log = Log.create({ service: "workspace-sync" })
+
+  async function workspaceEventLoop(space: Info, stop: AbortSignal) {
+    while (!stop.aborted) {
+      const res = await getAdaptor(space.config)
+        .request(space.config, "GET", "/event", undefined, stop)
+        .catch(() => undefined)
+      if (!res || !res.ok || !res.body) {
+        await Bun.sleep(1000)
+        continue
+      }
+      await parseSSE(res.body, stop, (event) => {
+        const payload = event as { type?: string; properties?: any }
+        void mirrorWorkspaceEvent(space, payload).catch((error) => {
+          log.warn("workspace event mirror failed", {
+            workspaceID: space.id,
+            error,
+            type: payload?.type,
+          })
+        })
+        GlobalBus.emit("event", {
+          directory: space.id,
+          payload,
+        })
+      })
+      await Bun.sleep(250)
+    }
+  }
+
+  export function startSyncing(project: Project.Info) {
+    void (async () => {
+      const spaces = (await list(project)).filter((space) => space.config.type !== "worktree")
+      spaces.forEach(startSpaceSync)
+    })()
+
+    return {
+      async stop() {
+        const spaces = await list(project)
+        spaces.forEach((space) => stopSpaceSync(space.id))
+      },
+    }
+  }
+
+  export function stopAllSyncing() {
+    for (const id of [...syncControllers.keys()]) {
+      stopSpaceSync(id)
+    }
+  }
+}