openpalm 0.11.0-beta.7 → 0.11.0-beta.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openpalm",
-  "version": "0.11.0-beta.7",
+  "version": "0.11.0-beta.9",
   "type": "module",
   "license": "MPL-2.0",
   "description": "OpenPalm CLI — install and manage a self-hosted OpenPalm stack",
@@ -12,6 +12,11 @@
   "bin": {
     "openpalm": "./bin/openpalm.js"
   },
+  "files": [
+    "bin",
+    "dist",
+    "README.md"
+  ],
   "scripts": {
     "start": "bun run src/main.ts",
     "test": "bun test",
@@ -31,7 +36,7 @@
     "bun": ">=1.0.0"
   },
   "dependencies": {
-    "@openpalm/lib": ">=0.11.0-beta.5 <1.0.0",
+    "@openpalm/lib": ">=0.11.0-beta.8 <1.0.0",
     "citty": "^0.2.1",
     "yaml": "^2.8.0"
   }

package/playwright.config.ts

@@ -1,16 +0,0 @@
-import { defineConfig } from '@playwright/test';
-
-const WIZARD_PORT = 18200;
-
-export default defineConfig({
-	testDir: 'e2e',
-	webServer: {
-		command: `bun run e2e/start-wizard-server.ts ${WIZARD_PORT}`,
-		port: WIZARD_PORT,
-		stdout: 'pipe',
-		reuseExistingServer: !process.env.CI,
-	},
-	use: {
-		baseURL: `http://localhost:${WIZARD_PORT}`,
-	},
-});

package/src/commands/addon.ts

@@ -1,131 +0,0 @@
-import { defineCommand } from 'citty';
-import {
-  buildComposeCliArgs,
-  getAddonServiceNames,
-  listAvailableAddonIds,
-  listEnabledAddonIds,
-  setAddonEnabled,
-} from '@openpalm/lib';
-import { ensureValidState } from '../lib/cli-state.ts';
-import { runComposeWithPreflight } from '../lib/cli-compose.ts';
-import { runDockerCompose } from '../lib/docker.ts';
-
-function requireKnownAddon(name: string): void {
-  const available = listAvailableAddonIds();
-  const hint = available.length > 0 ? ` Run \`openpalm addon list\` to see the available addons.` : '';
-  if (!available.includes(name)) {
-    throw new Error(`Addon "${name}" is not available. Known addons: ${available.join(', ') || '(none)'}.${hint}`);
-  }
-}
-
-export async function runAddonListAction(): Promise<void> {
-  const state = ensureValidState();
-  const enabled = new Set(listEnabledAddonIds(state.homeDir));
-  const available = listAvailableAddonIds();
-
-  if (available.length === 0) {
-    console.log('No registry addons are available.');
-    return;
-  }
-
-  for (const name of available) {
-    console.log(`${enabled.has(name) ? '[enabled]' : '[disabled]'} ${name}`);
-  }
-}
-
-export async function runAddonEnableAction(name: string): Promise<void> {
-  requireKnownAddon(name);
-  const state = ensureValidState();
-  const mutation = setAddonEnabled(state.homeDir, state.stackDir, name, true);
-  if (!mutation.ok) throw new Error(mutation.error);
-
-  if (!mutation.changed) {
-    console.log(`Addon "${name}" is already enabled.`);
-    return;
-  }
-
-  console.log(`Enabled addon "${name}".`);
-
-  if (mutation.services.length === 0) return;
-
-  try {
-    const nextState = ensureValidState();
-    await runComposeWithPreflight(nextState, ['up', '-d', ...mutation.services]);
-    console.log(`Started services: ${mutation.services.join(', ')}`);
-  } catch (err) {
-    console.warn(
-      `Warning: addon "${name}" was enabled but its services were not started automatically: ${err instanceof Error ? err.message : String(err)}`,
-    );
-  }
-}
-
-export async function runAddonDisableAction(name: string): Promise<void> {
-  requireKnownAddon(name);
-  const state = ensureValidState();
-  const services = getAddonServiceNames(state.homeDir, name);
-  const wasEnabled = listEnabledAddonIds(state.homeDir).includes(name);
-
-  if (wasEnabled && services.length > 0) {
-    try {
-      await runDockerCompose([...buildComposeCliArgs(state), 'stop', ...services]);
-      console.log(`Stopped services: ${services.join(', ')}`);
-    } catch (err) {
-      console.warn(
-        `Warning: failed to stop services for addon "${name}" before disabling it: ${err instanceof Error ? err.message : String(err)}`,
-      );
-    }
-  }
-
-  const mutation = setAddonEnabled(state.homeDir, state.stackDir, name, false);
-  if (!mutation.ok) throw new Error(mutation.error);
-
-  if (!mutation.changed) {
-    console.log(`Addon "${name}" is already disabled.`);
-    return;
-  }
-
-  console.log(`Disabled addon "${name}".`);
-}
-
-const enableCmd = defineCommand({
-  meta: { name: 'enable', description: 'Enable a registry addon' },
-  args: {
-    name: { type: 'positional', description: 'Addon name', required: true },
-  },
-  async run({ args }) {
-    const name = String(args._?.[0] ?? '').trim();
-    if (!name) throw new Error('Addon name is required. Run `openpalm addon list` to see the available addons.');
-    await runAddonEnableAction(name);
-  },
-});
-
-const disableCmd = defineCommand({
-  meta: { name: 'disable', description: 'Disable a registry addon' },
-  args: {
-    name: { type: 'positional', description: 'Addon name', required: true },
-  },
-  async run({ args }) {
-    const name = String(args._?.[0] ?? '').trim();
-    if (!name) throw new Error('Addon name is required. Run `openpalm addon list` to see the available addons.');
-    await runAddonDisableAction(name);
-  },
-});
-
-const listCmd = defineCommand({
-  meta: { name: 'list', description: 'List registry addons and whether they are enabled' },
-  async run() {
-    await runAddonListAction();
-  },
-});
-
-export default defineCommand({
-  meta: {
-    name: 'addon',
-    description: 'Enable, disable, or list registry addons',
-  },
-  subCommands: {
-    list: listCmd,
-    enable: enableCmd,
-    disable: disableCmd,
-  },
-});

package/src/commands/automations.ts

@@ -1,63 +0,0 @@
-import { defineCommand } from 'citty';
-import { execFile } from 'node:child_process';
-import { existsSync, readdirSync } from 'node:fs';
-import { join } from 'node:path';
-import { resolveOpenPalmHome } from '@openpalm/lib';
-
-async function automationsCheck(): Promise<void> {
-  const home = resolveOpenPalmHome();
-  const tasksDir = join(home, 'stash', 'tasks');
-
-  if (!existsSync(tasksDir)) {
-    console.log('No tasks directory found at', tasksDir);
-    process.exit(0);
-  }
-
-  const taskFiles = readdirSync(tasksDir).filter((f) => f.endsWith('.md'));
-  if (taskFiles.length === 0) {
-    console.log('No automation tasks installed.');
-    process.exit(0);
-  }
-
-  console.log(`Found ${taskFiles.length} automation task(s):`);
-  for (const file of taskFiles) {
-    console.log(`  - ${file.replace('.md', '')}`);
-  }
-
-  // Check crontab for registered tasks
-  await new Promise<void>((resolve) => {
-    execFile('crontab', ['-l'], (error, stdout) => {
-      if (error) {
-        console.log('No crontab found — tasks not yet registered (assistant not started?)');
-        resolve();
-        return;
-      }
-      const registered = taskFiles.filter((f) => stdout.includes(f.replace('.md', '')));
-      console.log(`Registered in crontab: ${registered.length}/${taskFiles.length}`);
-      if (registered.length < taskFiles.length) {
-        console.log(
-          "Run 'akm tasks sync' inside the assistant container to register remaining tasks."
-        );
-      }
-      resolve();
-    });
-  });
-}
-
-export default defineCommand({
-  meta: {
-    name: 'automations',
-    description: 'Manage automation tasks',
-  },
-  subCommands: {
-    check: defineCommand({
-      meta: {
-        name: 'check',
-        description: 'Report automation task registration status',
-      },
-      async run() {
-        await automationsCheck();
-      },
-    }),
-  },
-});

package/src/commands/install.ts

@@ -1,305 +0,0 @@
-import { defineCommand } from 'citty';
-import { join } from 'node:path';
-import { createInterface } from 'node:readline';
-import cliPkg from '../../package.json' with { type: 'json' };
-import { defaultWorkDir } from '../lib/paths.ts';
-import { resolveOpenPalmHome, resolveConfigDir } from '@openpalm/lib';
-import { ensureSecrets, ensureStackEnv } from '../lib/env.ts';
-import { ensureDirectoryTree, seedOpenPalmDir, seedUiBuild } from '../lib/io.ts';
-import { openBrowser } from '../lib/browser.ts';
-import { runDockerCompose } from '../lib/docker.ts';
-import {
-  backupOpenPalmHome,
-  buildComposeCliArgs,
-  ensureOpenCodeConfig, ensureOpenCodeSystemConfig,
-  performSetup,
-  applyInstall,
-  buildManagedServices,
-  createLogger,
-  resolveRequestedImageTag,
-  type SetupSpec,
-} from '@openpalm/lib';
-import { detectHostInfo } from '../lib/host-info.ts';
-import { ensureValidState } from '../lib/cli-state.ts';
-
-const logger = createLogger('cli:install');
-
-async function resolveDefaultInstallRef(): Promise<string> {
-  try {
-    const res = await fetch('https://github.com/itlackey/openpalm/releases/latest', { redirect: 'manual', signal: AbortSignal.timeout(10000) });
-    const match = (res.headers.get('location') ?? '').match(/\/tag\/(v[0-9]+\.[0-9]+\.[0-9]+[^\s]*)$/);
-    if (match?.[1]) return match[1];
-  } catch { /* fall through */ }
-  return cliPkg.version ? `v${cliPkg.version}` : 'main';
-}
-
-export default defineCommand({
-  meta: {
-    name: 'install',
-    description: 'Bootstrap home dirs, download assets, run setup wizard, start core services',
-  },
-  args: {
-    force: {
-      type: 'boolean',
-      description: 'Skip "already installed" check',
-      default: false,
-    },
-    version: {
-      type: 'string',
-      description: 'Install specific repository ref (default: latest release)',
-    },
-    start: {
-      type: 'boolean',
-      description: 'Start services after install (use --no-start to skip)',
-      default: true,
-    },
-    open: {
-      type: 'boolean',
-      description: 'Open browser after install (use --no-open to skip)',
-      default: true,
-    },
-    file: {
-      type: 'string',
-      alias: 'f',
-      description: 'Path to setup config file (JSON or YAML) — skips wizard',
-    },
-    yes: {
-      type: 'boolean',
-      alias: 'y',
-      description: 'Auto-confirm destructive prompts (e.g. --force backup of existing OP_HOME)',
-      default: false,
-    },
-  },
-  async run({ args }) {
-    try {
-      const version = args.version || await resolveDefaultInstallRef();
-      await bootstrapInstall({
-        force: args.force,
-        version,
-        noStart: !args.start,
-        noOpen: !args.open,
-        file: args.file,
-        assumeYes: args.yes,
-      });
-    } catch (err) {
-      console.error(`Error: ${err instanceof Error ? err.message : String(err)}`);
-      process.exit(1);
-    }
-  },
-});
-
-type InstallOptions = {
-  force: boolean;
-  version: string;
-  noStart: boolean;
-  noOpen: boolean;
-  file?: string;
-  assumeYes: boolean;
-};
-
-/**
- * Prompt the user for a y/N confirmation on stdin/stdout. Returns false in
- * any non-interactive context (no TTY) so CI runs do not hang waiting on
- * input — callers must pair this with an explicit `--yes` flag for
- * unattended invocations.
- */
-async function promptYesNo(question: string): Promise<boolean> {
-  if (!process.stdin.isTTY || !process.stdout.isTTY) return false;
-  const rl = createInterface({ input: process.stdin, output: process.stdout });
-  try {
-    const answer = await new Promise<string>((resolve) => rl.question(`${question} `, resolve));
-    return /^y(es)?$/i.test(answer.trim());
-  } finally {
-    rl.close();
-  }
-}
-
-async function requireCmd(cmd: string[], msg: string): Promise<void> {
-  if ((await Bun.spawn(cmd, { stdout: 'ignore', stderr: 'ignore' }).exited) !== 0) throw new Error(msg);
-}
-
-async function requireDocker(): Promise<void> {
-  if (!Bun.which('docker')) throw new Error('Docker is not installed. Install Docker first: https://docs.docker.com/get-docker/');
-  await requireCmd(['docker', 'info'], 'Docker is not running (or current user lacks permission). Start Docker and retry.');
-  await requireCmd(['docker', 'compose', 'version'], 'Docker Compose v2 is required. Install it: https://docs.docker.com/compose/install/');
-}
-
-async function deployServices(mode: string, pull = true): Promise<string[]> {
-  const state = ensureValidState();
-  await applyInstall(state);
-  const managedServices = await buildManagedServices(state);
-  const composeArgs = buildComposeCliArgs(state);
-  if (pull) await runDockerCompose([...composeArgs, 'pull', ...managedServices]).catch(() => console.warn('Warning: image pull failed.'));
-  await runDockerCompose([...composeArgs, 'up', '-d', ...managedServices]);
-  console.log(JSON.stringify({ ok: true, mode, services: managedServices }, null, 2));
-  return managedServices;
-}
-
-async function parseConfigFile(filePath: string, raw: string): Promise<Record<string, unknown>> {
-  const ext = filePath.toLowerCase();
-  const isYaml = ext.endsWith('.yaml') || ext.endsWith('.yml');
-  if (!isYaml && !ext.endsWith('.json')) throw new Error(`Unsupported config file format: ${filePath}. Use .json or .yaml.`);
-  try {
-    return isYaml ? (await import('yaml')).parse(raw) : JSON.parse(raw);
-  } catch (err) {
-    throw new Error(`Failed to parse setup config '${filePath}': ${err instanceof Error ? err.message : String(err)}`);
-  }
-}
-
-export async function bootstrapInstall(options: InstallOptions): Promise<void> {
-  const homeDir = resolveOpenPalmHome();
-  const configDir = resolveConfigDir();
-  const stateDir = `${homeDir}/state`;
-  const workDir = defaultWorkDir();
-
-  // Use config/stack/stack.env (always present after a successful install) as the
-  // canonical "already installed" indicator.
-  const alreadyInstalled = await Bun.file(join(configDir, 'stack', 'stack.env')).exists();
-  if (alreadyInstalled && !options.force) {
-    throw new Error('OpenPalm appears to already be installed. Re-run install with --force to continue.');
-  }
-
-  if (alreadyInstalled && options.force) {
-    // Use the helper's own backup-path convention so the prompt is honest about
-    // where the existing install will land. Match backupOpenPalmHome():
-    // `${homeDir}.backup.${YYYYMMDD-HHMMSS}`.
-    const now = new Date();
-    const stamp =
-      `${now.getFullYear()}${String(now.getMonth() + 1).padStart(2, '0')}${String(now.getDate()).padStart(2, '0')}` +
-      `-${String(now.getHours()).padStart(2, '0')}${String(now.getMinutes()).padStart(2, '0')}${String(now.getSeconds()).padStart(2, '0')}`;
-    const plannedBackup = `${homeDir}.backup.${stamp}`;
-
-    // Skip the prompt when --yes was passed OR when there's no TTY (CI/scripts).
-    // Without the TTY exemption we would silently hang a non-interactive
-    // pipeline waiting for stdin, which is worse than auto-confirming.
-    const interactive = process.stdin.isTTY && process.stdout.isTTY;
-    if (!options.assumeYes && interactive) {
-      const proceed = await promptYesNo(
-        `--force will move the existing OpenPalm install at ${homeDir} to ${plannedBackup}. Continue? [y/N]`,
-      );
-      if (!proceed) {
-        console.log('Install aborted. Re-run with --yes (or -y) to skip this confirmation in non-interactive use.');
-        return;
-      }
-    }
-    const backupDir = backupOpenPalmHome(homeDir);
-    if (backupDir) {
-      console.log(`Backed up existing OP_HOME to ${backupDir}`);
-    }
-  }
-
-  // ── Bootstrap files ────────────────────────────────────────────────────
-  await prepareInstallFiles(homeDir, configDir, stateDir, workDir, options.version);
-
-  // ── Configure ──────────────────────────────────────────────────────────
-  // File-based install: read config, run performSetup, optionally deploy
-  if (options.file) {
-    await runFileInstall(options.file, options.noStart);
-    return;
-  }
-
-  // Interactive wizard: start the admin UI which serves the setup wizard
-  const needsWizard = !alreadyInstalled || options.force;
-  if (needsWizard) {
-    await runWizardInstall(options.noOpen);
-    return;
-  }
-
-  // Update mode (already installed, no --force): just redeploy
-  if (options.noStart) {
-    console.log('Config updated. Run `openpalm start` to start services.');
-    return;
-  }
-  await requireDocker();
-  await deployServices('update', false);
-}
-
-async function prepareInstallFiles(
-  homeDir: string, configDir: string, stateDir: string, workDir: string, version: string,
-): Promise<void> {
-  console.log('Preparing directories...');
-  await ensureDirectoryTree(homeDir, configDir, '', '', workDir);
-
-  try { await Bun.write(join(stateDir, 'host.json'), JSON.stringify(await detectHostInfo(), null, 2) + '\n'); }
-  catch (err) { logger.debug('failed to write host.json', { error: String(err) }); }
-
-  // Seed OP_HOME from .openpalm/ (local source if available, else GitHub tarball)
-  await seedOpenPalmDir(version, homeDir, configDir, stateDir);
-  // Install UI build to state/ui/ (local build if available, else GitHub release asset)
-  await seedUiBuild(version, stateDir);
-
-  console.log('Configuring secrets...');
-  await ensureSecrets(stateDir);
-  await ensureStackEnv(homeDir, configDir, workDir, version, resolveRequestedImageTag(version) ?? undefined);
-
-  for (const [path, content] of [
-    [join(configDir, 'stack', 'guardian.env'), '# Guardian channel HMAC secrets — managed by openpalm\n'],
-    [join(configDir, 'stack', 'auth.json'), '{}\n'],
-    [join(homeDir, 'stash', 'vaults', 'user.env'), '# OpenPalm user vault — add LLM API keys and other secrets here\n'],
-  ] as const) {
-    if (!(await Bun.file(path).exists())) await Bun.write(path, content);
-  }
-
-  try { ensureOpenCodeConfig(); ensureOpenCodeSystemConfig(); } catch (err) { logger.debug('failed to ensure OpenCode config', { error: String(err) }); }
-}
-
-/**
- * Launch the UI host server to handle first-time setup.
- *
- * The SvelteKit UI detects that setup is not complete (via hooks.server.ts)
- * and redirects to /setup where the wizard runs. Deploy is triggered from
- * within the UI process after the user completes the wizard.
- *
- * Pre-flight: `requireDocker()` runs FIRST so users hit our friendly Docker
- * error before the browser opens to a wizard that will fail at the end of
- * a 10-step flow.
- */
-async function runWizardInstall(noOpen: boolean): Promise<void> {
-  await requireDocker();
-  const port = Number(process.env.OP_HOST_UI_PORT) || 3880;
-  console.log(`Setup wizard: http://localhost:${port}/setup`);
-  const { startUIServer } = await import('../lib/ui-server.ts');
-  await startUIServer({ open: !noOpen, port });
-}
-
-async function runFileInstall(filePath: string, noStart: boolean): Promise<void> {
-  console.log(`Reading setup config from ${filePath}...`);
-  if (!(await Bun.file(filePath).exists())) {
-    throw new Error(`Setup config file not found: ${filePath}. Check the --file path and try again.`);
-  }
-  const config = await parseConfigFile(filePath, await Bun.file(filePath).text());
-
-  // Normalize old wrapped format: { spec: { version, capabilities }, capabilities: [...] }
-  // into flat format:              { version, capabilities: {...}, connections: [...] }
-  if (config.spec && typeof config.spec === 'object') {
-    const spec = config.spec as Record<string, unknown>;
-    // Old format had connections array as top-level "capabilities"
-    if (Array.isArray(config.capabilities)) config.connections = config.capabilities;
-    config.version = spec.version;
-    config.capabilities = spec.capabilities;
-    delete config.spec;
-  }
-
-  if (config.version !== 2) throw new Error('Setup config must be version 2. See example.spec.yaml for the format.');
-  if (!config.capabilities || typeof config.capabilities !== 'object' || Array.isArray(config.capabilities)) {
-    throw new Error('Setup config must contain a "capabilities" object (llm, embeddings).');
-  }
-
-  // Resolve security.uiLoginPassword from environment when not in spec.
-  // Phase 4 (auth/proxy refactor) renamed the env var to OP_UI_LOGIN_PASSWORD
-  // and the spec field to security.uiLoginPassword.
-  const security = (config.security ?? {}) as Record<string, unknown>;
-  if (!security.uiLoginPassword && process.env.OP_UI_LOGIN_PASSWORD) {
-    security.uiLoginPassword = process.env.OP_UI_LOGIN_PASSWORD;
-    config.security = security;
-  }
-
-  const result = await performSetup(config as unknown as SetupSpec);
-  if (!result.ok) throw new Error(`Setup failed: ${result.error}`);
-  console.log('Setup complete.');
-  if (noStart) { console.log('Config written. Run `openpalm start` to start services.'); return; }
-  await requireDocker();
-  await deployServices('install');
-}
-
-

package/src/commands/logs.ts

@@ -1,25 +0,0 @@
-import { defineCommand } from 'citty';
-import { ensureValidState } from '../lib/cli-state.ts';
-import { runComposeReadOnly } from '../lib/cli-compose.ts';
-
-export async function runLogsAction(services: string[]): Promise<void> {
-  const state = ensureValidState();
-  await runComposeReadOnly(state, ['logs', '--tail', '100', ...services]);
-}
-
-export default defineCommand({
-  meta: {
-    name: 'logs',
-    description: 'Tail last 100 log lines for services',
-  },
-  args: {
-    services: {
-      type: 'positional',
-      description: 'Service names (omit for all)',
-      required: false,
-    },
-  },
-  async run({ args }) {
-    await runLogsAction(args._ ?? []);
-  },
-});

package/src/commands/restart.ts

@@ -1,37 +0,0 @@
-import { defineCommand } from 'citty';
-import { buildManagedServices } from '@openpalm/lib';
-import { ensureValidState } from '../lib/cli-state.ts';
-import { runComposeWithPreflight } from '../lib/cli-compose.ts';
-
-export default defineCommand({
-  meta: {
-    name: 'restart',
-    description: 'Restart services (all or named)',
-  },
-  args: {
-    services: {
-      type: 'positional',
-      description: 'Service names to restart (omit for all)',
-      required: false,
-    },
-  },
-  async run({ args }) {
-    const services = args._ ?? [];
-    await runRestartAction(services);
-  },
-});
-
-export async function runRestartAction(services: string[]): Promise<void> {
-  if (services.length === 0) {
-    // Restart all managed services (admin included if enabled)
-    const state = ensureValidState();
-    const managedServices = await buildManagedServices(state);
-    await runComposeWithPreflight(state, ['restart', ...managedServices]);
-    return;
-  }
-
-  const state = ensureValidState();
-  for (const service of services) {
-    await runComposeWithPreflight(state, ['restart', service]);
-  }
-}

package/src/commands/rollback.ts

@@ -1,44 +0,0 @@
-import { defineCommand } from 'citty';
-import { ensureValidState } from '../lib/cli-state.ts';
-import { runComposeWithPreflight } from '../lib/cli-compose.ts';
-import {
-  buildManagedServices,
-  createState,
-  restoreSnapshot,
-  hasSnapshot,
-  snapshotTimestamp,
-} from '@openpalm/lib';
-
-export default defineCommand({
-  meta: {
-    name: 'rollback',
-    description: 'Restore the most recent configuration snapshot and restart services',
-  },
-  async run() {
-    if (!hasSnapshot()) {
-      console.error('No rollback snapshot available.');
-      process.exit(1);
-    }
-
-    const ts = snapshotTimestamp();
-    console.log(`Restoring snapshot from ${ts ?? 'unknown'}...`);
-
-    // Create state without persisting so we don't overwrite live config
-    // before the snapshot is restored.
-    const rollbackState = createState();
-    restoreSnapshot(rollbackState);
-
-    console.log('Snapshot restored. Rebuilding configuration...');
-
-    // Now validate and persist with the restored files in place
-    const state = ensureValidState();
-
-    const managedServices = await buildManagedServices(state);
-
-    await runComposeWithPreflight(state, [
-      'up', '-d', '--remove-orphans', ...managedServices,
-    ]);
-
-    console.log('Rollback complete.');
-  },
-});