opencode-drive 0.1.2 → 0.1.3

package/src/cli/instance.ts

@@ -1,47 +1,40 @@
-import { chmod, mkdir, rm } from "node:fs/promises"
+import { mkdir, rm } from "node:fs/promises"
 import { tmpdir } from "node:os"
 import { join, resolve } from "node:path"
-import { registerInstance, registryDirectory, transferInstance, unregisterInstance } from "./registry.js"
-import type { InstanceManifest } from "./types.js"
+import { defaultBackendPort, defaultPort } from "../client/index.js"
 
 export interface LaunchOptions {
-  readonly name?: string
+  readonly name: string
   readonly command?: ReadonlyArray<string>
   readonly dev?: string
   readonly state?: string
+  readonly scripted?: boolean
   readonly visible?: boolean
   readonly env?: Readonly<Record<string, string>>
 }
 
 export async function launchInstance(options: LaunchOptions = {}) {
-  const name = options.name ?? "default"
-  const artifacts = resolve(join(tmpdir(), "opencode-drive", `${name}-${randomSuffix()}`))
-  const cwd = artifacts
-  const [uiPort, backendPort] = await Promise.all([freePort(), freePort()])
+  const artifacts = resolve(
+    join(tmpdir(), "opencode-drive", `run-${crypto.randomUUID().slice(0, 6)}`),
+  )
+  const logs = join(artifacts, "logs")
   const endpoints = {
-    ui: `ws://127.0.0.1:${uiPort}`,
-    backend: `ws://127.0.0.1:${backendPort}`,
-  }
-  const manifest: InstanceManifest = {
-    version: 1,
-    name,
-    pid: process.pid,
-    startedAt: new Date().toISOString(),
-    mode: "simulated",
-    headless: options.visible !== true,
-    cwd,
-    artifacts,
-    endpoints,
+    ui: `ws://127.0.0.1:${await freePort()}`,
+    backend: `ws://127.0.0.1:${await freePort()}`,
   }
+  const drive = join(artifacts, "drive")
   await Promise.all([
-    mkdir(artifacts, { recursive: true }),
-    mkdir(cwd, { recursive: true }),
+    mkdir(logs, { recursive: true }),
+    mkdir(drive, { recursive: true }),
     mkdir(join(artifacts, "home", ".cache"), { recursive: true }),
     mkdir(join(artifacts, "home", ".config"), { recursive: true }),
     mkdir(join(artifacts, "home", ".local", "share"), { recursive: true }),
     mkdir(join(artifacts, "home", ".local", "state"), { recursive: true }),
   ])
-  const state = options.state ? resolve(options.state) : join(artifacts, "state")
+  await Bun.write(join(drive, `${options.name}.json`), `${JSON.stringify({ endpoints }, undefined, 2)}\n`)
+  const state = options.state
+    ? resolve(options.state)
+    : join(artifacts, "state")
   if (!options.state) {
     await rm(state, { recursive: true, force: true })
     await Promise.all([
@@ -57,16 +50,17 @@ export async function launchInstance(options: LaunchOptions = {}) {
           providers: {
             simulation: {
               name: "Simulation",
+              package: "aisdk:@ai-sdk/openai-compatible",
+              settings: { baseURL: "https://api.openai.com/v1" },
               request: { body: { apiKey: "sim-key" } },
               models: {
                 "sim-model": {
                   name: "Simulated Model",
-                  api: {
-                    type: "aisdk",
-                    package: "@ai-sdk/openai-compatible",
-                    url: "https://api.openai.com/v1",
+                  capabilities: {
+                    tools: true,
+                    input: ["text"],
+                    output: ["text"],
                   },
-                  capabilities: { tools: true, input: ["text"], output: ["text"] },
                   limit: { context: 128000, output: 16000 },
                 },
               },
@@ -78,96 +72,98 @@ export async function launchInstance(options: LaunchOptions = {}) {
       )}\n`,
     )
   }
-  await registerInstance(manifest)
   const environment = cleanEnv({
     ...process.env,
     ...options.env,
-    DRIVE_REGISTRY_DIR: registryDirectory(),
     OPENCODE_SIMULATE: "1",
     OPENCODE_SIMULATE_STATE: state,
-    OPENCODE_DRIVE: name,
+    DRIVE_REGISTRY_DIR: drive,
+    OPENCODE_DRIVE: options.name,
     OPENCODE_DRIVE_RENDERER: options.visible ? "visible" : "headless",
-    OPENCODE_CONFIG_DIR: join(cwd, ".opencode"),
+    OPENCODE_CONFIG_DIR: join(artifacts, ".opencode"),
     OPENCODE_DB: ":memory:",
+    OPENCODE_LOG_LEVEL: !options.visible
+      ? "INFO"
+      : process.env.OPENCODE_LOG_LEVEL,
     OPENCODE_TEST_HOME: artifacts,
     XDG_CACHE_HOME: join(artifacts, "home", ".cache"),
     XDG_CONFIG_HOME: join(artifacts, "home", ".config"),
-    XDG_DATA_HOME: join(artifacts, "home", ".local", "share"),
+    XDG_DATA_HOME: logs,
     XDG_STATE_HOME: join(artifacts, "home", ".local", "state"),
   })
   const command = options.dev
-    ? await prepareDev(cwd, options.dev)
+    ? await prepareDev(artifacts, options.dev)
     : options.command?.length
       ? [...options.command]
       : ["opencode2"]
-  const launch = join(artifacts, "launch.json")
-  await Bun.write(launch, `${JSON.stringify({ command, environment }, undefined, 2)}\n`)
-  await chmod(launch, 0o600)
-  const visible = options.visible === true
-  let child = spawn(command, environment, manifest)
-  const lifecycle = {
-    detached: false,
-    stopping: undefined as Promise<void> | undefined,
-    restarting: undefined as Promise<void> | undefined,
-  }
+  const spawn = () =>
+    Bun.spawn(command, {
+      cwd: artifacts,
+      env: environment,
+      stdin: options.visible ? "inherit" : "ignore",
+      stdout: !options.visible
+        ? Bun.file(join(logs, "opencode.stdout.log"))
+        : "inherit",
+      stderr: !options.visible
+        ? Bun.file(join(logs, "opencode.stderr.log"))
+        : "inherit",
+    })
+  let child = spawn()
+  let stopping: Promise<void> | undefined
+  let restarting: Promise<void> | undefined
   return {
-    manifest,
+    artifacts,
+    logs,
+    endpoints,
     get child() {
       return child
     },
-    async waitForDrive(requirement: "ui" | "backend" | "both" = "both", timeout = 60_000) {
-      const urls = requirement === "both"
-        ? [endpoints.ui, endpoints.backend]
-        : [requirement === "ui" ? endpoints.ui : endpoints.backend]
-      await Promise.all(urls.map((url) => waitForWebSocket(url, child.exited, timeout)))
-    },
-    async detach() {
-      await transferInstance(manifest, child.pid)
-      child.unref()
-      lifecycle.detached = true
+    async waitForDrive(
+      requirement: "ui" | "backend" | "both" = "both",
+      timeout = 60_000,
+    ) {
+      const urls =
+        requirement === "both"
+          ? [endpoints.ui, endpoints.backend]
+          : [endpoints[requirement]]
+      await Promise.all(
+        urls.map((url) => waitForWebSocket(url, child.exited, timeout)),
+      )
     },
-    restart() {
-      if (lifecycle.restarting) return lifecycle.restarting
-      lifecycle.restarting = (async () => {
+    async restart() {
+      if (restarting) return restarting
+      restarting = (async () => {
         await terminate(child)
-        child = spawn(command, environment, manifest)
+        child = spawn()
         await Promise.all([
           waitForWebSocket(endpoints.ui, child.exited, 60_000),
           waitForWebSocket(endpoints.backend, child.exited, 60_000),
         ])
       })().finally(() => {
-        lifecycle.restarting = undefined
+        restarting = undefined
       })
-      return lifecycle.restarting
+      return restarting
     },
     async wait() {
       while (true) {
         const current = child
         const status = await current.exited
-        if (lifecycle.restarting) {
-          await lifecycle.restarting
+        if (restarting) {
+          await restarting
           continue
         }
-        if (child !== current) continue
+        if (current !== child) continue
         return status
       }
     },
-    stop(force = false) {
-      if (lifecycle.detached) return Promise.resolve()
-      if (lifecycle.stopping) return lifecycle.stopping
-      lifecycle.stopping = (async () => {
-        if (lifecycle.restarting) await lifecycle.restarting.catch(() => undefined)
-        if (force) {
-          if (child.exitCode === null) child.kill("SIGKILL")
-        } else if (child.exitCode === null) {
-          child.kill("SIGTERM")
-          await Promise.race([child.exited, Bun.sleep(1_000)])
-        }
-        if (child.exitCode === null) child.kill("SIGKILL")
-        await child.exited
-        await unregisterInstance(name, process.pid)
+    stop() {
+      if (stopping) return stopping
+      stopping = (async () => {
+        if (restarting) await restarting.catch(() => undefined)
+        await terminate(child)
+        await stopService(join(artifacts, "home", ".local", "state"))
       })()
-      return lifecycle.stopping
+      return stopping
     },
   }
 }
@@ -180,67 +176,48 @@ async function terminate(child: Bun.Subprocess) {
   await child.exited
 }
 
-export async function restartInstance(manifest: InstanceManifest) {
-  const value: unknown = await Bun.file(join(manifest.artifacts, "launch.json")).json()
-  if (!isLaunchInfo(value)) throw new Error(`drive instance "${manifest.name}" has no valid restart metadata`)
-  const child = spawn(value.command, value.environment, manifest)
-  await transferInstance(manifest, child.pid)
-  try {
-    await Promise.all([
-      waitForWebSocket(manifest.endpoints.ui, child.exited, 60_000),
-      waitForWebSocket(manifest.endpoints.backend, child.exited, 60_000),
-    ])
-    child.unref()
-    return child.pid
-  } catch (error) {
-    if (child.exitCode === null) child.kill("SIGKILL")
-    await child.exited
-    throw error
-  }
-}
-
-function spawn(command: ReadonlyArray<string>, environment: Readonly<Record<string, string>>, manifest: InstanceManifest) {
-  return Bun.spawn([...command], {
-    cwd: manifest.cwd,
-    env: environment,
-    stdin: manifest.headless ? "ignore" : "inherit",
-    stdout: manifest.headless ? Bun.file(join(manifest.artifacts, "opencode.stdout.log")) : "inherit",
-    stderr: manifest.headless ? Bun.file(join(manifest.artifacts, "opencode.stderr.log")) : "inherit",
-  })
-}
-
-function isLaunchInfo(value: unknown): value is {
-  readonly command: ReadonlyArray<string>
-  readonly environment: Readonly<Record<string, string>>
-} {
-  if (typeof value !== "object" || value === null) return false
-  if (!("command" in value) || !Array.isArray(value.command) || !value.command.every((item) => typeof item === "string")) return false
-  if (!("environment" in value) || typeof value.environment !== "object" || value.environment === null || Array.isArray(value.environment)) return false
-  return Object.values(value.environment).every((item) => typeof item === "string")
-}
-
 async function prepareDev(cwd: string, directory: string) {
   const root = resolve(directory)
   const entrypoint = join(root, "packages", "cli", "src", "index.ts")
-  if (!(await Bun.file(entrypoint).exists())) throw new Error(`OpenCode development entrypoint not found: ${entrypoint}`)
-  const solidPackage = join(root, "packages", "tui", "node_modules", "@opentui", "solid", "package.json")
+  if (!(await Bun.file(entrypoint).exists()))
+    throw new Error(`OpenCode development entrypoint not found: ${entrypoint}`)
+  const solidPackage = join(
+    root,
+    "packages",
+    "tui",
+    "node_modules",
+    "@opentui",
+    "solid",
+    "package.json",
+  )
   if (!(await Bun.file(solidPackage).exists())) {
-    throw new Error(`OpenCode development dependency not found: ${solidPackage}; run bun install in ${root}`)
+    throw new Error(
+      `OpenCode development dependency not found: ${solidPackage}; run bun install in ${root}`,
+    )
   }
   const info: unknown = await Bun.file(solidPackage).json()
-  if (!isPackageInfo(info)) throw new Error(`Invalid @opentui/solid package metadata: ${solidPackage}`)
-  await Bun.write(join(cwd, "package.json"), `${JSON.stringify({
-    private: true,
-    dependencies: { "@opentui/solid": info.version },
-  }, undefined, 2)}\n`)
+  if (!isPackageInfo(info))
+    throw new Error(`Invalid @opentui/solid package metadata: ${solidPackage}`)
+  await Bun.write(
+    join(cwd, "package.json"),
+    `${JSON.stringify(
+      {
+        private: true,
+        dependencies: { "@opentui/solid": info.version },
+      },
+      undefined,
+      2,
+    )}\n`,
+  )
   const install = Bun.spawn([process.execPath, "install"], {
     cwd,
     stdin: "ignore",
-    stdout: "inherit",
-    stderr: "inherit",
+    stdout: "ignore",
+    stderr: "ignore",
   })
   const status = await install.exited
-  if (status !== 0) throw new Error(`bun install failed in ${cwd} with status ${status}`)
+  if (status !== 0)
+    throw new Error(`bun install failed in ${cwd} with status ${status}`)
   return [
     process.execPath,
     "--conditions=browser",
@@ -249,27 +226,89 @@ async function prepareDev(cwd: string, directory: string) {
   ]
 }
 
-function isPackageInfo(value: unknown): value is { readonly version: string } {
-  return typeof value === "object" && value !== null && "version" in value && typeof value.version === "string"
-}
-
 async function freePort() {
-  const server = Bun.serve({ port: 0, hostname: "127.0.0.1", fetch: () => new Response() })
+  const server = Bun.serve({
+    hostname: "127.0.0.1",
+    port: 0,
+    fetch: () => new Response(),
+  })
   const port = server.port
   await server.stop(true)
   return port
 }
 
-async function waitForWebSocket(url: string, exited: Promise<number>, timeout: number) {
+async function stopService(state: string) {
+  const files = [
+    join(state, "opencode", "service-local.json"),
+    join(state, "opencode", "service.json"),
+  ]
+  const info = await Promise.all(
+    files.map((file) =>
+      Bun.file(file)
+        .json()
+        .catch(() => undefined),
+    ),
+  )
+  await Promise.all(
+    info.map(async (value) => {
+      if (!isServiceInfo(value)) return
+      try {
+        process.kill(value.pid, "SIGTERM")
+      } catch {
+        return
+      }
+      const deadline = Date.now() + 1_000
+      while (Date.now() < deadline && alive(value.pid)) await Bun.sleep(25)
+      if (alive(value.pid)) process.kill(value.pid, "SIGKILL")
+    }),
+  )
+}
+
+function isServiceInfo(value: unknown): value is { readonly pid: number } {
+  return (
+    typeof value === "object" &&
+    value !== null &&
+    "pid" in value &&
+    typeof value.pid === "number"
+  )
+}
+
+function alive(pid: number) {
+  try {
+    process.kill(pid, 0)
+    return true
+  } catch {
+    return false
+  }
+}
+
+function isPackageInfo(value: unknown): value is { readonly version: string } {
+  return (
+    typeof value === "object" &&
+    value !== null &&
+    "version" in value &&
+    typeof value.version === "string"
+  )
+}
+
+async function waitForWebSocket(
+  url: string,
+  exited: Promise<number>,
+  timeout: number,
+) {
   const deadline = Date.now() + timeout
   while (Date.now() < deadline) {
     const connected = await Promise.race([
-      open(url).then((socket) => {
-        socket.close()
-        return true
-      }).catch(() => false),
+      open(url)
+        .then((socket) => {
+          socket.close()
+          return true
+        })
+        .catch(() => false),
       exited.then((code) => {
-        throw new Error(`OpenCode exited with status ${code} before ${url} became ready`)
+        throw new Error(
+          `OpenCode exited with status ${code} before ${url} became ready`,
+        )
       }),
     ])
     if (connected) return
@@ -281,15 +320,21 @@ async function waitForWebSocket(url: string, exited: Promise<number>, timeout: n
 function open(url: string) {
   return new Promise<WebSocket>((resolveSocket, reject) => {
     const socket = new WebSocket(url)
-    socket.addEventListener("open", () => resolveSocket(socket), { once: true })
-    socket.addEventListener("error", () => reject(new Error(`cannot connect to ${url}`)), { once: true })
+    socket.addEventListener("open", () => resolveSocket(socket), {
+      once: true,
+    })
+    socket.addEventListener(
+      "error",
+      () => reject(new Error(`cannot connect to ${url}`)),
+      { once: true },
+    )
   })
 }
 
-function randomSuffix() {
-  return crypto.randomUUID().slice(0, 6)
-}
-
 function cleanEnv(env: Readonly<Record<string, string | undefined>>) {
-  return Object.fromEntries(Object.entries(env).filter((entry): entry is [string, string] => entry[1] !== undefined))
+  return Object.fromEntries(
+    Object.entries(env).filter(
+      (entry): entry is [string, string] => entry[1] !== undefined,
+    ),
+  )
 }

package/src/cli/mock-backend.ts

@@ -0,0 +1,25 @@
+import { connectBackendSimulation } from "../client/index.js"
+
+const response = "This is a sample response from opencode-drive."
+
+export async function connectMockBackend(endpoint: string) {
+  const backend = await connectBackendSimulation({ url: endpoint })
+  let closing = false
+  await backend.attach((request) => {
+    void backend
+      .chunk(request.id, [{ type: "textDelta", text: response }])
+      .then(() => backend.finish(request.id))
+      .catch((error) => {
+        if (!closing)
+          console.error(
+            `error: ${error instanceof Error ? error.message : String(error)}`,
+          )
+      })
+  })
+  return {
+    close() {
+      closing = true
+      backend.close()
+    },
+  }
+}

package/src/cli/registry.ts

@@ -1,92 +1,54 @@
+import { mkdir, rm } from "node:fs/promises"
 import { homedir } from "node:os"
-import { basename, join } from "node:path"
-import { mkdir, open, readdir, rename, rm } from "node:fs/promises"
-import type { InstanceManifest } from "./types.js"
+import { join } from "node:path"
+
+export interface InstanceManifest {
+  readonly version: 1
+  readonly name: string
+  readonly pid: number
+  readonly artifacts: string
+  readonly visible: boolean
+  readonly endpoints: { readonly ui: string; readonly backend: string }
+  readonly control: string
+}
 
 export function registryDirectory() {
-  if (process.env.DRIVE_REGISTRY_DIR) return process.env.DRIVE_REGISTRY_DIR
-  return join(process.env.XDG_STATE_HOME ?? join(homedir(), ".local", "state"), "opencode-drive", "instances")
+  return process.env.DRIVE_REGISTRY_DIR ?? join(homedir(), ".local", "state", "opencode-drive", "instances")
 }
 
 export function manifestPath(name: string) {
   return join(registryDirectory(), `${validateName(name)}.json`)
 }
 
-export async function registerInstance(manifest: InstanceManifest) {
-  await mkdir(registryDirectory(), { recursive: true })
-  const file = manifestPath(manifest.name)
-  const lock = `${file}.lock`
-  const existing = await readManifest(file)
-  if (existing && processAlive(existing.pid)) throw new Error(`drive instance "${manifest.name}" is already running`)
-  if (existing) await rm(file, { force: true })
-  const handle = await open(lock, "wx").catch(() => undefined)
-  if (!handle) throw new Error(`drive instance "${manifest.name}" is already starting`)
-  try {
-    const current = await readManifest(file)
-    if (current && processAlive(current.pid)) throw new Error(`drive instance "${manifest.name}" is already running`)
-    const temporary = `${file}.${process.pid}.tmp`
-    await Bun.write(temporary, `${JSON.stringify(manifest, undefined, 2)}\n`)
-    await rename(temporary, file)
-    return file
-  } finally {
-    await handle.close()
-    await rm(lock, { force: true })
-  }
+export function controlPath(name: string) {
+  return join(registryDirectory(), `${validateName(name)}.sock`)
 }
 
-export async function unregisterInstance(name: string, pid: number) {
-  const file = manifestPath(name)
-  const manifest = await readManifest(file)
-  if (manifest?.pid !== pid) return
-  await rm(file, { force: true })
-}
-
-export async function transferInstance(manifest: InstanceManifest, pid: number) {
-  const file = manifestPath(manifest.name)
-  const current = await readManifest(file)
-  if (current?.pid !== manifest.pid) throw new Error(`drive instance "${manifest.name}" changed ownership`)
-  const temporary = `${file}.${process.pid}.tmp`
-  await Bun.write(temporary, `${JSON.stringify({ ...manifest, pid }, undefined, 2)}\n`)
-  await rename(temporary, file)
+export async function register(manifest: InstanceManifest) {
+  await mkdir(registryDirectory(), { recursive: true })
+  const existing = await read(manifest.name).catch(() => undefined)
+  if (existing && alive(existing.pid)) throw new Error(`drive instance "${manifest.name}" is already running`)
+  await rm(manifest.control, { force: true })
+  await Bun.write(manifestPath(manifest.name), `${JSON.stringify(manifest, undefined, 2)}\n`)
 }
 
-export async function resolveInstance(name?: string) {
-  const instances = await listInstances()
-  if (name) {
-    const instance = instances.find((item) => item.name === name)
-    if (!instance) throw new Error(`drive instance "${name}" was not found`)
-    return instance
+export async function resolveInstance(name = "default") {
+  const manifest = await read(name)
+  if (!alive(manifest.pid)) {
+    await unregister(name)
+    throw new Error(`drive instance "${name}" is not running`)
   }
-  if (instances.length === 1) return instances[0]!
-  if (instances.length === 0) throw new Error("no drive instances are running")
-  throw new Error(`multiple drive instances are running; pass --name (${instances.map((item) => item.name).join(", ")})`)
+  return manifest
 }
 
-export async function listInstances() {
-  await mkdir(registryDirectory(), { recursive: true })
-  const directory = registryDirectory()
-  const files = (await readdir(directory)).filter((file) => file.endsWith(".json"))
-  const entries = await Promise.all(files.map((file) => readManifest(join(directory, file))))
-  const active = entries.filter((entry): entry is InstanceManifest => entry !== undefined && processAlive(entry.pid))
-  const activeNames = new Set(active.map((entry) => entry.name))
-  await Promise.all(
-    files
-      .filter((file) => !activeNames.has(basename(file, ".json")))
-      .map((file) => rm(join(directory, file), { force: true })),
-  )
-  return active.sort((a, b) => a.name.localeCompare(b.name))
+export async function unregister(name: string) {
+  await Promise.all([rm(manifestPath(name), { force: true }), rm(controlPath(name), { force: true })])
 }
 
-async function readManifest(file: string): Promise<InstanceManifest | undefined> {
-  if (!(await Bun.file(file).exists())) return undefined
-  try {
-    const value = await Bun.file(file).json()
-    if (!isManifest(value)) return undefined
-    return value
-  } catch {
-    await rm(file, { force: true })
-    return undefined
-  }
+async function read(name: string): Promise<InstanceManifest> {
+  const value: unknown = await Bun.file(manifestPath(name)).json().catch(() => undefined)
+  if (!isManifest(value)) throw new Error(`drive instance "${name}" was not found`)
+  return value
 }
 
 function isManifest(value: unknown): value is InstanceManifest {
@@ -94,16 +56,19 @@ function isManifest(value: unknown): value is InstanceManifest {
   if (!("version" in value) || value.version !== 1) return false
   if (!("name" in value) || typeof value.name !== "string") return false
   if (!("pid" in value) || typeof value.pid !== "number") return false
-  if (!("startedAt" in value) || typeof value.startedAt !== "string") return false
-  if (!("mode" in value) || (value.mode !== "simulated" && value.mode !== "real")) return false
-  if (!("headless" in value) || typeof value.headless !== "boolean") return false
-  if (!("cwd" in value) || typeof value.cwd !== "string") return false
   if (!("artifacts" in value) || typeof value.artifacts !== "string") return false
+  if (!("visible" in value) || typeof value.visible !== "boolean") return false
+  if (!("control" in value) || typeof value.control !== "string") return false
   if (!("endpoints" in value) || typeof value.endpoints !== "object" || value.endpoints === null) return false
   return "ui" in value.endpoints && typeof value.endpoints.ui === "string" && "backend" in value.endpoints && typeof value.endpoints.backend === "string"
 }
 
-function processAlive(pid: number) {
+function validateName(name: string) {
+  if (!/^[a-zA-Z0-9][a-zA-Z0-9._-]{0,63}$/.test(name)) throw new Error(`invalid instance name "${name}"`)
+  return name
+}
+
+function alive(pid: number) {
   try {
     process.kill(pid, 0)
     return true
@@ -111,10 +76,3 @@ function processAlive(pid: number) {
     return false
   }
 }
-
-function validateName(name: string) {
-  if (!/^[a-zA-Z0-9][a-zA-Z0-9._-]{0,63}$/.test(name)) {
-    throw new Error("instance names must contain 1-64 letters, numbers, dots, underscores, or dashes")
-  }
-  return name
-}