@otto-assistant/otto 0.1.0 → 0.1.1

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@otto-assistant/otto",
-  "version": "0.1.0",
-  "description": "Otto — terminal UI distribution wrapper for opencode + kimaki + opencode-agent-memory",
+  "version": "0.1.1",
+  "description": "Otto — terminal UI distribution wrapper for opencode + kimaki + mempalace",
   "type": "module",
   "bin": {
     "otto": "./dist/cli.js"
@@ -15,8 +15,17 @@
       "default": "./dist/index.js"
     }
   },
-  "files": ["src", "dist"],
-  "keywords": ["otto", "opencode", "kimaki", "ai-agent", "distribution"],
+  "files": [
+    "src",
+    "dist"
+  ],
+  "keywords": [
+    "otto",
+    "opencode",
+    "kimaki",
+    "ai-agent",
+    "distribution"
+  ],
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -25,6 +34,7 @@
   "scripts": {
     "build": "rm -rf dist *.tsbuildinfo && tsc && chmod +x dist/cli.js",
     "dev": "tsc --watch",
+    "build:artifacts": "./scripts/build-local-artifacts.sh",
     "prepublishOnly": "pnpm build",
     "test": "vitest run",
     "test:watch": "vitest"
@@ -34,7 +44,7 @@
     "picocolors": "^1.1.1"
   },
   "devDependencies": {
-    "@types/node": "^22.10.0",
+    "@types/node": "^22.19.17",
     "typescript": "^5.7.3",
     "vitest": "^3.2.0"
   }

package/src/cli.ts

@@ -15,9 +15,28 @@ import {
   type OpenCodeConfig,
 } from "./config.js"
 import { installMissingPackages, upgradePackage, planStableUpgrades } from "./installer.js"
+import fs from "node:fs"
+import path from "node:path"
 import { hasKimakiBinary, restartKimaki } from "./lifecycle.js"
-import { checkPackagePresence, checkConfigHealth, checkDirectoryHealth } from "./health.js"
+import { checkPackagePresence, checkConfigHealth, checkDirectoryHealth, checkTenantHealth } from "./health.js"
 import { syncUpstreams } from "./sync.js"
+import { runCompose } from "./docker.js"
+import { ensureTenantScaffold, resolveTenantMode } from "./tenant.js"
+import {
+  searchSkills,
+  getAllIndexedSkills,
+  listInstalledSkills,
+  installSkillFromIndex,
+  installSkillsBaseline,
+  removeSkill,
+  ensureSkillsIndex,
+  getConfiguredRepos,
+  loadSkillsIndex,
+  DEFAULT_SKILL_REPOS,
+  type SkillIndexEntry,
+  type SkillMeta,
+} from "./skills.js"
+import { GENTLEMAN_SKILLS_BASELINE } from "./skills-baseline.js"
 
 const args = process.argv.slice(2)
 const command = args[0] ?? ""
@@ -82,7 +101,23 @@ async function cmdInstall(): Promise<void> {
     console.log("Created otto-subagent-threads skill")
   }
 
-  // 5. Restart kimaki if needed — but NOT if running inside kimaki
+  // 5. Install Otto-core skills from skills repo (best-effort)
+  try {
+    ensureSkillsIndex()
+    const allSkills = getAllIndexedSkills()
+    const installedSkillNames = new Set(listInstalledSkills().map((s) => s.name))
+    const coreSkills = allSkills.filter(
+      (s) => s.source === "otto-assistant/skills" && !installedSkillNames.has(s.name),
+    )
+    for (const skill of coreSkills) {
+      const ok = installSkillFromIndex(skill.name)
+      if (ok) console.log(`Installed skill: ${skill.name}`)
+    }
+  } catch {
+    console.log("⚠ Could not fetch skills from GitHub (offline?). Skipping.")
+  }
+
+  // 6. Restart kimaki if needed — but NOT if running inside kimaki
   //    (kimaki restart kills the current opencode session)
   const runningInsideKimaki = !!process.env.KIMAKI
   if (configChanged || installed.length > 0) {
@@ -198,6 +233,18 @@ async function cmdStatus(): Promise<void> {
   console.log(`  ask before thread delete: ${configHealth.subagentThreadsAskBeforeDelete ? "yes" : "no"}`)
   console.log(`  auto delete thread on complete: ${configHealth.subagentThreadsAutoDelete ? "yes" : "no"}`)
   console.log(`  kimaki process: ${configHealth.kimakiRunning ? "running" : "not running"}`)
+
+  console.log("\nSkills:")
+  const skillsInstalled = listInstalledSkills()
+  console.log(`  installed: ${skillsInstalled.length > 0 ? skillsInstalled.map((s) => s.name).join(", ") : "(none)"}`)
+  try {
+    const index = loadSkillsIndex()
+    const repoCount = Object.keys(index.repos).length
+    const totalIndexed = getAllIndexedSkills().length
+    console.log(`  indexed: ${totalIndexed} skills from ${repoCount} repos`)
+  } catch {
+    console.log("  indexed: (unavailable)")
+  }
 }
 
 async function cmdDoctor(): Promise<void> {
@@ -223,9 +270,9 @@ async function cmdDoctor(): Promise<void> {
     hasErrors = true
   }
   if (configHealth.memoryPluginEnabled) {
-    console.log("  ✓ opencode-agent-memory plugin enabled")
+    console.log("  ✓ mempalace plugin enabled")
   } else {
-    console.log("  ✗ opencode-agent-memory plugin NOT enabled — run `otto install`")
+    console.log("  ✗ mempalace plugin NOT enabled — run `otto install`")
     hasErrors = true
   }
   if (configHealth.subagentPolicyInjected) {
@@ -248,9 +295,386 @@ async function cmdDoctor(): Promise<void> {
     if (d.status === "error") hasErrors = true
   }
 
+  console.log("\nChecking skills...")
+  const skillsInstalled = listInstalledSkills()
+  if (skillsInstalled.length > 0) {
+    console.log(`  ✓ ${skillsInstalled.length} skill(s) installed`)
+  } else {
+    console.log("  ⚠ No skills installed — run `otto skills add --all`")
+  }
+  try {
+    const totalIndexed = getAllIndexedSkills().length
+    if (totalIndexed > 0) {
+      console.log(`  ✓ Skills index available (${totalIndexed} skills)`)
+    } else {
+      console.log("  ⚠ Skills index empty — run `otto skills update`")
+    }
+  } catch {
+    console.log("  ⚠ Skills index unavailable")
+  }
+
   console.log(hasErrors ? "\n✗ Issues found. Run `otto install` to fix." : "\n✓ All checks passed!")
 }
 
+// ---------------------------------------------------------------------------
+// otto skills sub-commands
+// ---------------------------------------------------------------------------
+
+async function cmdSkills(subArgs: string[]): Promise<void> {
+  const skillCommand = subArgs[0] ?? ""
+
+  switch (skillCommand) {
+    case "list":
+      cmdSkillsList()
+      break
+    case "search": {
+      const query = subArgs.slice(1).join(" ")
+      if (!query) {
+        console.log("Usage: otto skills search <query>")
+        process.exit(1)
+      }
+      cmdSkillsSearch(query)
+      break
+    }
+    case "browse":
+      cmdSkillsBrowse()
+      break
+    case "add": {
+      const arg = subArgs[1]
+      if (!arg || arg === "--all") {
+        await cmdSkillsAddAll()
+      } else {
+        await cmdSkillsAddOne(arg)
+      }
+      break
+    }
+    case "remove": {
+      const name = subArgs[1]
+      if (!name) {
+        console.log("Usage: otto skills remove <name>")
+        process.exit(1)
+      }
+      cmdSkillsRemove(name)
+      break
+    }
+    case "update":
+      cmdSkillsUpdate()
+      break
+    case "repos":
+      cmdSkillsRepos()
+      break
+    default:
+      console.log(`Otto skills — discover and install agent skills from public repos
+
+Usage:
+  otto skills search <query>     Search skills by name/description
+  otto skills browse             Browse all available skills
+  otto skills list               List installed skills
+  otto skills add <name>         Install a skill
+  otto skills add --all          Install all skills from otto-assistant/skills
+  otto skills update             Refresh skills index from GitHub
+  otto skills remove <name>      Remove an installed skill
+  otto skills repos              Show configured skill repositories
+`)
+      break
+  }
+}
+
+function cmdSkillsSearch(query: string): void {
+  console.log(`Searching: "${query}"\n`)
+
+  const { refreshed } = ensureSkillsIndex()
+  if (refreshed > 0) {
+    console.log(`Updated index (${refreshed} repo(s) refreshed).\n`)
+  }
+
+  const results = searchSkills(query)
+  if (results.length === 0) {
+    console.log("No skills found.")
+    return
+  }
+
+  for (const skill of results) {
+    console.log(`  ${skill.name} — ${skill.description}`)
+    console.log(`    source: ${skill.source}`)
+  }
+
+  console.log(`\n${results.length} skill(s) found. Install with: otto skills add <name>`)
+}
+
+function cmdSkillsBrowse(): void {
+  console.log("Otto skills — browsing all available\n")
+
+  const { refreshed } = ensureSkillsIndex()
+  if (refreshed > 0) {
+    console.log(`Updated index (${refreshed} repo(s) refreshed).\n`)
+  }
+
+  const allSkills = getAllIndexedSkills()
+  const installed = new Set(listInstalledSkills().map((s) => s.name))
+
+  // Group by source repo
+  const byRepo: Record<string, SkillIndexEntry[]> = {}
+  for (const skill of allSkills) {
+    if (!byRepo[skill.source]) byRepo[skill.source] = []
+    byRepo[skill.source].push(skill)
+  }
+
+  for (const [repo, skills] of Object.entries(byRepo)) {
+    console.log(`${repo} (${skills.length} skills):`)
+    for (const skill of skills) {
+      const icon = installed.has(skill.name) ? "✓" : "•"
+      console.log(`  ${icon} ${skill.name} — ${skill.description}`)
+    }
+    console.log()
+  }
+
+  const totalAvailable = allSkills.filter((s) => !installed.has(s.name)).length
+  console.log(`${allSkills.length} total, ${totalAvailable} available to install.`)
+}
+
+function cmdSkillsList(): void {
+  console.log("Otto skills\n")
+
+  const installed = listInstalledSkills()
+  if (installed.length > 0) {
+    console.log("Installed:")
+    for (const s of installed) {
+      console.log(`  ✓ ${s.name} — ${s.description}`)
+    }
+  } else {
+    console.log("Installed: (none)")
+  }
+
+  console.log(`\nUse "otto skills browse" to see all available skills.`)
+  console.log(`Use "otto skills search <query>" to search.`)
+}
+
+async function cmdSkillsAddOne(name: string): Promise<void> {
+  console.log(`Installing skill: ${name}\n`)
+
+  ensureSkillsIndex()
+
+  const success = installSkillFromIndex(name)
+  if (!success) {
+    console.error(`Error: skill "${name}" not found. Run "otto skills search <query>" to find skills.`)
+    process.exit(1)
+  }
+
+  console.log(`Installed ${name} → ~/.config/opencode/skills/${name}/`)
+  console.log("Done!")
+}
+
+async function cmdSkillsAddAll(): Promise<void> {
+  console.log("Installing all skills from otto-assistant/skills...\n")
+
+  ensureSkillsIndex()
+  const allSkills = getAllIndexedSkills()
+  const ottoSkills = allSkills.filter((s) => s.source === "otto-assistant/skills")
+
+  if (ottoSkills.length === 0) {
+    console.log("No skills found in otto-assistant/skills. Check your connection.")
+    return
+  }
+
+  const installed = new Set(listInstalledSkills().map((s) => s.name))
+  let added = 0
+
+  for (const skill of ottoSkills) {
+    if (installed.has(skill.name)) {
+      console.log(`  ✓ ${skill.name} (already installed)`)
+      continue
+    }
+    const success = installSkillFromIndex(skill.name)
+    if (success) {
+      console.log(`  + ${skill.name}`)
+      added++
+    } else {
+      console.log(`  ✗ ${skill.name} (failed)`)
+    }
+  }
+
+  if (added === 0) {
+    console.log("\nAll skills already installed.")
+  } else {
+    console.log(`\nInstalled ${added} skill(s).`)
+  }
+  console.log("Done!")
+}
+
+function cmdSkillsUpdate(): void {
+  console.log("Refreshing skills index from GitHub...\n")
+
+  const { refreshed, total } = ensureSkillsIndex(0) // force refresh all
+
+  if (refreshed === 0 && total === 0) {
+    console.log("No repos configured.")
+    return
+  }
+
+  console.log(`Refreshed ${refreshed}/${total} repo(s).`)
+
+  const allSkills = getAllIndexedSkills()
+  console.log(`Index now has ${allSkills.length} skills.`)
+  console.log("Done!")
+}
+
+function cmdSkillsRemove(name: string): void {
+  console.log(`Removing skill: ${name}\n`)
+
+  const success = removeSkill(name)
+  if (!success) {
+    console.error(`Error: skill "${name}" is not installed.`)
+    process.exit(1)
+  }
+
+  console.log(`Removed ${name}.`)
+  console.log("Done!")
+}
+
+function cmdSkillsRepos(): void {
+  console.log("Configured skill repositories:\n")
+
+  const repos = getConfiguredRepos()
+  for (const repo of repos) {
+    console.log(`  ${repo}`)
+  }
+
+  console.log(`\n${repos.length} repo(s) configured.`)
+}
+
+async function cmdTenant(subArgs: string[]): Promise<void> {
+  const tenantCommand = subArgs[0] ?? ""
+  const tenantPathArg = subArgs[1]
+
+  if (tenantCommand === "skills") {
+    const action = subArgs[1] ?? ""
+    const pathArg = subArgs[2]
+    if (action !== "bootstrap" || !pathArg) {
+      console.log("Usage: otto tenant skills bootstrap <path>")
+      process.exit(1)
+    }
+
+    const tenantPath = path.resolve(pathArg)
+    const skillsDir = path.join(tenantPath, "memory", "opencode", "skills")
+
+    ensureSkillsIndex()
+    const report = installSkillsBaseline(GENTLEMAN_SKILLS_BASELINE, skillsDir)
+
+    console.log(`Skills baseline bootstrap: ${tenantPath}`)
+    console.log(`  Installed: ${report.installed.length > 0 ? report.installed.join(", ") : "(none)"}`)
+    console.log(`  Already present: ${report.alreadyPresent.length > 0 ? report.alreadyPresent.join(", ") : "(none)"}`)
+    if (report.failed.length > 0) {
+      console.log(`  Failed: ${report.failed.join(", ")}`)
+      process.exitCode = 2
+    } else {
+      console.log("  Failed: (none)")
+    }
+    return
+  }
+
+  if (!tenantPathArg) {
+    console.log("Usage: otto tenant <init|up|down|status|logs> <path>")
+    process.exit(1)
+  }
+
+  const tenantPath = path.resolve(tenantPathArg)
+
+  switch (tenantCommand) {
+    case "init": {
+      const result = ensureTenantScaffold(tenantPath)
+      if (result.created.length === 0) {
+        console.log(`Tenant scaffold already exists: ${tenantPath}`)
+      } else {
+        console.log(`Tenant scaffold ready: ${tenantPath}`)
+        console.log(`Created: ${result.created.join(", ")}`)
+      }
+      console.log(`
+Next steps — get your tenant running in 3 steps:
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+Step 1: Create a Discord Bot
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  1. Open https://discord.com/developers/applications
+  2. Click "New Application" → give it a name → Create
+  3. Go to "Bot" tab → Click "Reset Token" → Copy the token
+  4. Under "Privileged Gateway Intents" enable:
+     ✅ Message Content Intent
+     ✅ Server Members Intent (optional)
+  5. Go to "OAuth2" tab → "URL Generator"
+     Scopes: bot
+     Permissions: Send Messages, Read Message History, Add Reactions
+  6. Open the generated URL → add bot to your Discord server
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+Step 2: Configure your tenant
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  Edit ${tenantPath}/.env with your bot token:
+
+    KIMAKI_BOT_TOKEN=your-bot-token-here
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+Step 3: Start your tenant
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  docker compose -f ${tenantPath}/compose.yml up -d
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+Useful commands:
+  otto tenant status ${tenantPathArg}   — check health
+  otto tenant logs ${tenantPathArg}     — view logs
+  otto tenant down ${tenantPathArg}     — stop tenant
+  otto tenant skills bootstrap ${tenantPathArg} — install baseline skills
+`)
+      return
+    }
+    case "up": {
+      const mode = resolveTenantMode(process.env.OTTO_MODE)
+      if (mode === "admin") {
+        console.log("⚠ OTTO_MODE=admin enabled: tenant has elevated runtime profile.")
+      }
+      runCompose(tenantPath, ["up", "-d"])
+      return
+    }
+    case "down":
+      runCompose(tenantPath, ["down"])
+      return
+    case "logs": {
+      const follow = subArgs.includes("--follow") ? ["--follow"] : []
+      runCompose(tenantPath, ["logs", ...follow])
+      return
+    }
+    case "status": {
+      const health = checkTenantHealth({ tenantPath })
+      console.log(`Tenant status: ${tenantPath}`)
+      for (const item of health) {
+        const icon = item.status === "ok" ? "✓" : item.status === "warn" ? "⚠" : "✗"
+        console.log(`  ${icon} ${item.name}: ${item.message}`)
+      }
+      const composeExists = fs.existsSync(path.join(tenantPath, "compose.yml"))
+      const skipComposePs = process.env.OTTO_SKIP_COMPOSE_PS === "1"
+      if (composeExists && !skipComposePs) {
+        try {
+          runCompose(tenantPath, ["ps"])
+        } catch {
+          console.log("  ⚠ docker compose ps failed")
+        }
+      }
+      return
+    }
+    default:
+      console.log("Usage: otto tenant <init|up|down|status|logs> <path> | otto tenant skills bootstrap <path>")
+      process.exit(1)
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Main router
+// ---------------------------------------------------------------------------
+
 async function main(): Promise<void> {
   switch (command) {
     case "install":
@@ -268,17 +692,38 @@ async function main(): Promise<void> {
     case "sync":
       await syncUpstreams()
       break
+    case "skills":
+      await cmdSkills(args.slice(1))
+      break
+    case "tenant":
+      await cmdTenant(args.slice(1))
+      break
     default:
-      console.log(`Otto — terminal UI distribution for opencode + kimaki + opencode-agent-memory
+      console.log(`Otto — terminal UI distribution for opencode + kimaki + mempalace
 
 Usage:
-  otto install            Install missing packages + configure
-  otto upgrade            Upgrade to stable (manifest-pinned) versions
-  otto upgrade stable     Upgrade to manifest-pinned versions
-  otto upgrade latest     Upgrade to npm latest versions
-  otto status             Show installed versions + config health
-  otto doctor             Validate all integration points
-  otto sync               Trigger upstream sync for all forked repos
+  otto tenant init <path>   Create compose-first tenant scaffold
+  otto tenant up <path>     Start tenant with docker compose
+  otto tenant down <path>   Stop tenant with docker compose
+  otto tenant status <path> Show tenant preflight + compose status
+  otto tenant logs <path>   Show tenant logs (add --follow)
+  otto tenant skills bootstrap <path> Install baseline skills for tenant
+
+  otto install              Legacy: install missing npm packages + configure
+  otto upgrade              Legacy: upgrade to stable (manifest-pinned) versions
+  otto upgrade stable       Legacy: upgrade to manifest-pinned versions
+  otto upgrade latest       Legacy: upgrade to npm latest versions
+  otto status               Show installed versions + config health
+  otto doctor               Validate all integration points
+  otto sync                 Trigger upstream sync for all forked repos
+  otto skills search <q>    Search skills across public repos
+  otto skills browse        Browse all available skills
+  otto skills list          List installed skills
+  otto skills add <name>    Install a skill
+  otto skills add --all     Install all skills from otto-assistant/skills
+  otto skills update        Refresh skills index
+  otto skills remove <name> Remove an installed skill
+  otto skills repos         Show configured skill repositories
 `)
       break
   }

package/src/config.test.ts

@@ -18,20 +18,20 @@ import os from "node:os"
 describe("config", () => {
   it("adds plugin to empty config", () => {
     const config: OpenCodeConfig = {}
-    const result = mergePlugins(config, "opencode-agent-memory")
-    expect(result.plugin).toEqual(["opencode-agent-memory"])
+    const result = mergePlugins(config, "mempalace")
+    expect(result.plugin).toEqual(["mempalace"])
   })
 
   it("appends plugin to existing array", () => {
     const config: OpenCodeConfig = { plugin: ["existing-plugin"] }
-    const result = mergePlugins(config, "opencode-agent-memory")
-    expect(result.plugin).toEqual(["existing-plugin", "opencode-agent-memory"])
+    const result = mergePlugins(config, "mempalace")
+    expect(result.plugin).toEqual(["existing-plugin", "mempalace"])
   })
 
   it("does not duplicate existing plugin", () => {
-    const config: OpenCodeConfig = { plugin: ["opencode-agent-memory"] }
-    const result = mergePlugins(config, "opencode-agent-memory")
-    expect(result.plugin).toEqual(["opencode-agent-memory"])
+    const config: OpenCodeConfig = { plugin: ["mempalace"] }
+    const result = mergePlugins(config, "mempalace")
+    expect(result.plugin).toEqual(["mempalace"])
   })
 
   it("preserves other config fields", () => {
@@ -40,10 +40,10 @@ describe("config", () => {
       plugin: ["existing"],
       provider: { cursor: { name: "Cursor" } },
     }
-    const result = mergePlugins(config, "opencode-agent-memory")
+    const result = mergePlugins(config, "mempalace")
     expect(result.model).toBe("gpt-4")
     expect(result.provider).toEqual({ cursor: { name: "Cursor" } })
-    expect(result.plugin).toEqual(["existing", "opencode-agent-memory"])
+    expect(result.plugin).toEqual(["existing", "mempalace"])
   })
 
   it("readOttoConfig returns defaults when otto.json missing", () => {

package/src/detect.test.ts

@@ -2,13 +2,14 @@ import { describe, expect, it } from "vitest"
 import { getInstalledVersion, detectPackage, type InstalledPackage } from "./detect.js"
 
 describe("detect", () => {
-  it("returns null for non-existent package", () => {
+  it("returns null for non-existent package", { timeout: 30_000 }, () => {
     const result = getInstalledVersion("nonexistent-package-xyz-123")
     expect(result).toBeNull()
   })
 
-  // These tests require kimaki to be globally installed (skipped on CI)
-  const describeIfInstalled = process.env.CI ? describe.skip : describe
+  // These tests require kimaki to be globally installed
+  const hasKimakiInstalled = getInstalledVersion("kimaki") !== null
+  const describeIfInstalled = hasKimakiInstalled ? describe : describe.skip
 
   describeIfInstalled("with kimaki installed", () => {
     it("detects an existing global package", () => {

package/src/docker.test.ts

@@ -0,0 +1,12 @@
+import { describe, expect, it } from "vitest"
+import { buildComposeCommand } from "./docker.js"
+
+describe("docker", () => {
+  it("builds docker compose command with tenant path", () => {
+    const cmd = buildComposeCommand("/tmp/tenant-a", ["up", "-d"])
+    expect(cmd).toEqual({
+      command: "docker",
+      args: ["compose", "-f", "/tmp/tenant-a/compose.yml", "up", "-d"],
+    })
+  })
+})

package/src/docker.ts

@@ -0,0 +1,23 @@
+import { execSync } from "node:child_process"
+import path from "node:path"
+
+export interface DockerComposeCommand {
+  command: string
+  args: string[]
+}
+
+export function buildComposeCommand(tenantPath: string, subArgs: string[]): DockerComposeCommand {
+  const composeFile = path.join(path.resolve(tenantPath), "compose.yml")
+  return {
+    command: "docker",
+    args: ["compose", "-f", composeFile, ...subArgs],
+  }
+}
+
+export function runCompose(tenantPath: string, subArgs: string[]): void {
+  const built = buildComposeCommand(tenantPath, subArgs)
+  execSync(`${built.command} ${built.args.join(" ")}`, {
+    stdio: "inherit",
+    timeout: 120_000,
+  })
+}