openpalm 0.9.8 → 0.9.10

package/src/main.test.ts

@@ -1,7 +1,8 @@
 import { afterEach, describe, expect, it, mock } from 'bun:test';
-import { existsSync, mkdirSync, writeFileSync, chmodSync, mkdtempSync, readFileSync, rmSync } from 'node:fs';
+import { existsSync, mkdirSync, writeFileSync, chmodSync, mkdtempSync, readFileSync, readdirSync, rmSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
+import { fileURLToPath } from 'node:url';
 import { detectHostInfo, main, reconcileStackEnvImageTag, resolveRequestedImageTag, upsertEnvValue } from './main.ts';
 
 // Helpers to mock Bun.spawn and Bun.which for tests that would otherwise
@@ -57,92 +58,57 @@ describe('cli main', () => {
     process.env.OPENPALM_ADMIN_TOKEN = originalOpenPalmAdminToken;
   });
 
-  it('calls containers pull for update (via admin when reachable)', async () => {
-    const calls: string[] = [];
-    process.env.OPENPALM_ADMIN_TOKEN = 'test-token';
-    globalThis.fetch = mock(async (input: string | URL) => {
-      calls.push(String(input));
-      return new Response('{"ok":true}', { status: 200 });
-    }) as typeof fetch;
-    console.log = mock(() => {}) as typeof console.log;
-
-    await main(['update']);
-
-    // tryAdminRequest attempts directly — no separate health check
-    expect(calls).toEqual([
-      'http://localhost:8100/admin/containers/pull',
-    ]);
-  });
-
-  it('uses ADMIN_TOKEN from the environment for admin requests', async () => {
-    const adminTokens: string[] = [];
-    process.env.ADMIN_TOKEN = 'env-admin-token';
-    delete process.env.OPENPALM_ADMIN_TOKEN;
-
-    globalThis.fetch = mock(async (_input: string | URL, init?: RequestInit) => {
-      const headers = new Headers(init?.headers);
-      adminTokens.push(headers.get('X-Admin-Token') ?? '');
-      return new Response('{"ok":true}', { status: 200 });
-    }) as typeof fetch;
-    console.log = mock(() => {}) as typeof console.log;
-
-    await main(['update']);
-
-    // Direct request — single call with token header
-    expect(adminTokens).toEqual(['env-admin-token']);
-  });
-
-  it('falls back to the legacy parent secrets.env for admin requests', async () => {
-    const base = mkdtempSync(join(tmpdir(), 'openpalm-config-'));
-    const configHome = join(base, 'openpalm');
-    const adminTokens: string[] = [];
+  it('runs bootstrap install directly without admin delegation', async () => {
+    const base = mkdtempSync(join(tmpdir(), 'openpalm-install-'));
+    const configHome = join(base, 'config');
+    const dataHome = join(base, 'data');
+    const stateHome = join(base, 'state');
+    const workDir = join(base, 'work');
+    const binDir = join(stateHome, 'bin');
 
-    mkdirSync(configHome, { recursive: true });
-    writeFileSync(join(configHome, 'secrets.env'), 'OPENPALM_ADMIN_TOKEN=\nADMIN_TOKEN=\n');
-    writeFileSync(join(base, 'secrets.env'), 'export ADMIN_TOKEN="legacy-admin-token"\n');
+    mkdirSync(binDir, { recursive: true });
+    writeFileSync(join(binDir, 'varlock'), '#!/bin/sh\nexit 0\n');
+    chmodSync(join(binDir, 'varlock'), 0o755);
 
     process.env.OPENPALM_CONFIG_HOME = configHome;
+    process.env.OPENPALM_DATA_HOME = dataHome;
+    process.env.OPENPALM_STATE_HOME = stateHome;
+    process.env.OPENPALM_WORK_DIR = workDir;
     delete process.env.ADMIN_TOKEN;
     delete process.env.OPENPALM_ADMIN_TOKEN;
 
-    globalThis.fetch = mock(async (_input: string | URL, init?: RequestInit) => {
-      const headers = new Headers(init?.headers);
-      adminTokens.push(headers.get('X-Admin-Token') ?? '');
-      return new Response('{"ok":true}', { status: 200 });
-    }) as typeof fetch;
-    console.log = mock(() => {}) as typeof console.log;
-
-    try {
-      await main(['update']);
-      // Direct request — single call with legacy token
-      expect(adminTokens).toEqual(['legacy-admin-token']);
-    } finally {
-      rmSync(base, { recursive: true, force: true });
-    }
-  });
-
-  it('calls admin install when stack is already running and token exists', async () => {
-    const calls: string[] = [];
-    process.env.OPENPALM_ADMIN_TOKEN = 'test-token';
+    mockDockerCli();
+    const fetchedUrls: string[] = [];
     globalThis.fetch = mock(async (input: string | URL) => {
       const url = String(input);
-      calls.push(url);
+      fetchedUrls.push(url);
       if (url.endsWith('/health')) {
         return new Response('ok', { status: 200 });
       }
-      return new Response('{\"ok\":true}', { status: 200 });
+      if (url.includes('/docker-compose.yml')) {
+        return new Response('services: {}\n', { status: 200 });
+      }
+      if (url.includes('/Caddyfile')) {
+        return new Response(':80 {\n}\n', { status: 200 });
+      }
+      if (url.includes('/secrets.env.schema') || url.includes('/stack.env.schema')) {
+        return new Response('KEY=string\n', { status: 200 });
+      }
+      return new Response('', { status: 503 });
     }) as typeof fetch;
     console.log = mock(() => {}) as typeof console.log;
+    console.warn = mock(() => {}) as typeof console.warn;
 
-    await main(['install']);
-
-    expect(calls).toEqual([
-      'http://localhost:8100/health',
-      'http://localhost:8100/admin/install',
-    ]);
+    try {
+      await main(['install', '--no-start', '--force', '--no-open']);
+      // Bootstrap runs directly, creating directories
+      expect(existsSync(join(dataHome, 'admin'))).toBe(true);
+    } finally {
+      rmSync(base, { recursive: true, force: true });
+    }
   });
 
-  it('falls back to bootstrap when stack is running but no token exists', async () => {
+  it('creates the admin data directory during bootstrap install', async () => {
     const base = mkdtempSync(join(tmpdir(), 'openpalm-install-'));
     const configHome = join(base, 'config');
     const dataHome = join(base, 'data');
@@ -158,16 +124,12 @@ describe('cli main', () => {
     process.env.OPENPALM_DATA_HOME = dataHome;
     process.env.OPENPALM_STATE_HOME = stateHome;
     process.env.OPENPALM_WORK_DIR = workDir;
-    delete process.env.ADMIN_TOKEN;
-    delete process.env.OPENPALM_ADMIN_TOKEN;
 
     mockDockerCli();
-    const fetchedUrls: string[] = [];
     globalThis.fetch = mock(async (input: string | URL) => {
       const url = String(input);
-      fetchedUrls.push(url);
       if (url.endsWith('/health')) {
-        return new Response('ok', { status: 200 });
+        throw new TypeError('fetch failed');
       }
       if (url.includes('/docker-compose.yml')) {
         return new Response('services: {}\n', { status: 200 });
@@ -181,24 +143,23 @@ describe('cli main', () => {
       return new Response('', { status: 503 });
     }) as typeof fetch;
     console.log = mock(() => {}) as typeof console.log;
-    console.warn = mock(() => {}) as typeof console.warn;
 
     try {
       await main(['install', '--no-start', '--force', '--no-open']);
-      // Should have fallen through to bootstrap, creating directories
       expect(existsSync(join(dataHome, 'admin'))).toBe(true);
     } finally {
       rmSync(base, { recursive: true, force: true });
     }
   });
 
-  it('creates the admin data directory during bootstrap install', async () => {
+  it('resolves version-pinned install ref (falls back to CLI package version)', async () => {
     const base = mkdtempSync(join(tmpdir(), 'openpalm-install-'));
     const configHome = join(base, 'config');
     const dataHome = join(base, 'data');
     const stateHome = join(base, 'state');
     const workDir = join(base, 'work');
     const binDir = join(stateHome, 'bin');
+    const fetchedUrls: string[] = [];
 
     mkdirSync(binDir, { recursive: true });
     writeFileSync(join(binDir, 'varlock'), '#!/bin/sh\nexit 0\n');
@@ -209,12 +170,20 @@ describe('cli main', () => {
     process.env.OPENPALM_STATE_HOME = stateHome;
     process.env.OPENPALM_WORK_DIR = workDir;
 
+    // Read the CLI package version to verify pinning behaviour
+    const cliPkg = JSON.parse(
+      readFileSync(new URL('../package.json', import.meta.url), 'utf8'),
+    ) as { version: string };
+    const expectedRef = `v${cliPkg.version}`;
+
     mockDockerCli();
     globalThis.fetch = mock(async (input: string | URL) => {
       const url = String(input);
+      fetchedUrls.push(url);
       if (url.endsWith('/health')) {
         throw new TypeError('fetch failed');
       }
+      // Respond to version-pinned asset URLs
       if (url.includes('/docker-compose.yml')) {
         return new Response('services: {}\n', { status: 200 });
       }
@@ -227,10 +196,20 @@ describe('cli main', () => {
       return new Response('', { status: 503 });
     }) as typeof fetch;
     console.log = mock(() => {}) as typeof console.log;
+    console.warn = mock(() => {}) as typeof console.warn;
 
     try {
       await main(['install', '--no-start', '--force', '--no-open']);
-      expect(existsSync(join(dataHome, 'admin'))).toBe(true);
+
+      // Verify that assets were fetched using the version-pinned ref, not 'main'
+      const composeUrl = fetchedUrls.find((u) => u.includes('/docker-compose.yml'));
+      expect(composeUrl).toBeDefined();
+      expect(composeUrl).toContain(expectedRef);
+      expect(composeUrl).not.toContain('/main/');
+
+      const caddyUrl = fetchedUrls.find((u) => u.includes('/Caddyfile'));
+      expect(caddyUrl).toBeDefined();
+      expect(caddyUrl).toContain(expectedRef);
     } finally {
       rmSync(base, { recursive: true, force: true });
     }
@@ -251,6 +230,65 @@ describe('npm bin launcher', () => {
 
     expect(launcher.startsWith('#!/usr/bin/env bun\n')).toBe(true);
   });
+
+  it('packs a real semver range for @openpalm/lib so published installs can resolve the latest compatible lib', {
+    timeout: 15000,
+  }, () => {
+    const cliPkg = JSON.parse(
+      readFileSync(new URL('../package.json', import.meta.url), 'utf8'),
+    ) as {
+      dependencies?: Record<string, string>;
+    };
+    const libPkg = JSON.parse(
+      readFileSync(new URL('../../lib/package.json', import.meta.url), 'utf8'),
+    ) as {
+      version: string;
+    };
+    const versionMatch = libPkg.version.match(/^(\d+)\.\d+\.\d+(?:-.+)?$/);
+    if (!versionMatch) throw new Error(`Unexpected lib version format: ${libPkg.version}`);
+    const libMajor = Number.parseInt(versionMatch[1], 10);
+
+    const expectedRange = `>=${libPkg.version} <${libMajor + 1}.0.0`;
+
+    expect(cliPkg.dependencies?.['@openpalm/lib']).toBe(expectedRange);
+
+    const packageDir = fileURLToPath(new URL('../', import.meta.url));
+    const packDir = mkdtempSync(join(tmpdir(), 'openpalm-cli-pack-'));
+
+    try {
+      const pack = Bun.spawnSync(
+        [process.execPath, 'pm', 'pack', '--destination', packDir, '--quiet'],
+        {
+          cwd: packageDir,
+          stdout: 'pipe',
+          stderr: 'pipe',
+        },
+      );
+
+      expect(pack.exitCode).toBe(0);
+
+      const tarball = readdirSync(packDir).find((name) => name.endsWith('.tgz'));
+      if (!tarball) throw new Error('Expected bun pm pack to produce a tarball');
+
+      const extract = Bun.spawnSync(
+        ['tar', '-xOf', join(packDir, tarball), 'package/package.json'],
+        {
+          stdout: 'pipe',
+          stderr: 'pipe',
+        },
+      );
+
+      expect(extract.exitCode).toBe(0);
+
+      const packedPkg = JSON.parse(new TextDecoder().decode(extract.stdout)) as {
+        dependencies?: Record<string, string>;
+      };
+
+      expect(packedPkg.dependencies?.['@openpalm/lib']).toBe(expectedRange);
+    } finally {
+      rmSync(packDir, { recursive: true, force: true });
+    }
+  });
 });
 
 describe('validate command', () => {