@robbiesrobotics/alice-agents 1.4.5 → 1.4.7

package/lib/license.mjs

@@ -7,19 +7,71 @@ const LICENSE_DIR = join(homedir(), '.alice');
 const LICENSE_FILE = join(LICENSE_DIR, 'license');
 const VALIDATE_URL = 'https://getalice.av3.ai/api/license/validate';
 const KEY_REGEX = /^ALICE-[A-Z0-9]{4}-[A-Z0-9]{4}-[A-Z0-9]{4}$/;
+const GRACE_PERIOD_MS = 72 * 60 * 60 * 1000;
+const REVALIDATE_INTERVAL_MS = 7 * 24 * 60 * 60 * 1000;
+
+function nowIso() {
+  return new Date().toISOString();
+}
+
+function parseLicenseRecord(raw) {
+  const trimmed = raw?.trim();
+  if (!trimmed) return null;
+
+  if (trimmed.startsWith('{')) {
+    try {
+      const parsed = JSON.parse(trimmed);
+      if (!parsed?.key) return null;
+      return parsed;
+    } catch {
+      return null;
+    }
+  }
+
+  return {
+    key: trimmed,
+    plan: 'pro',
+    status: 'validated',
+    validatedAt: null,
+    updatedAt: null,
+    source: 'legacy',
+  };
+}
+
+function createLicenseRecord(key, data = {}) {
+  return {
+    key: key.trim().toUpperCase(),
+    plan: data.plan || 'pro',
+    status: data.status || 'validated',
+    validatedAt: data.status === 'validated' ? (data.validatedAt || nowIso()) : (data.validatedAt || null),
+    graceUntil: data.status === 'grace' ? (data.graceUntil || new Date(Date.now() + GRACE_PERIOD_MS).toISOString()) : null,
+    updatedAt: nowIso(),
+    transport: data.transport || null,
+    source: data.source || 'local',
+  };
+}
+
+function shouldRevalidate(record) {
+  if (!record?.validatedAt) return true;
+  const validatedAt = Date.parse(record.validatedAt);
+  if (Number.isNaN(validatedAt)) return true;
+  return Date.now() - validatedAt >= REVALIDATE_INTERVAL_MS;
+}
 
 export function readStoredLicense() {
   try {
     if (!existsSync(LICENSE_FILE)) return null;
-    return readFileSync(LICENSE_FILE, 'utf8').trim();
+    return parseLicenseRecord(readFileSync(LICENSE_FILE, 'utf8'));
   } catch {
     return null;
   }
 }
 
-export function storeLicense(key) {
+export function storeLicense(key, data = {}) {
   mkdirSync(LICENSE_DIR, { recursive: true });
-  writeFileSync(LICENSE_FILE, key.trim(), 'utf8');
+  const record = createLicenseRecord(key, data);
+  writeFileSync(LICENSE_FILE, JSON.stringify(record, null, 2) + '\n', 'utf8');
+  return record;
 }
 
 export function isValidFormat(key) {
@@ -27,24 +79,116 @@ export function isValidFormat(key) {
 }
 
 export async function validateLicenseRemote(key) {
-  // Returns { valid: boolean, plan: string, message?: string }
+  // Returns { valid: boolean, plan?: string, message?: string, transient?: boolean, graceEligible?: boolean, transport?: string }
+  const normalizedKey = key.trim().toUpperCase();
+  const postBody = JSON.stringify({ key: normalizedKey });
+
   try {
-    const res = await fetch(`${VALIDATE_URL}?key=${encodeURIComponent(key)}`, {
+    const res = await fetch(VALIDATE_URL, {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: postBody,
       signal: AbortSignal.timeout(5000),
     });
-    if (!res.ok) return { valid: false, message: 'Validation service unavailable' };
-    return await res.json();
+    if (!res.ok && [404, 405, 415].includes(res.status)) {
+      const fallback = await fetch(`${VALIDATE_URL}?key=${encodeURIComponent(normalizedKey)}`, {
+        signal: AbortSignal.timeout(5000),
+      });
+      if (!fallback.ok) {
+        return {
+          valid: false,
+          message: 'Validation service unavailable',
+          transient: fallback.status >= 500,
+          graceEligible: isValidFormat(normalizedKey),
+          transport: 'get',
+        };
+      }
+      return { ...(await fallback.json()), transport: 'get' };
+    }
+    if (!res.ok) {
+      return {
+        valid: false,
+        message: res.status >= 500 ? 'Validation service unavailable' : 'License key not recognized',
+        transient: res.status >= 500,
+        graceEligible: res.status >= 500 && isValidFormat(normalizedKey),
+        transport: 'post',
+      };
+    }
+    return { ...(await res.json()), transport: 'post' };
   } catch {
-    // Network error — fail open (allow install, validate next time)
-    return { valid: true, plan: 'pro', message: 'offline' };
+    return {
+      valid: false,
+      message: 'Validation service unavailable',
+      transient: true,
+      graceEligible: isValidFormat(normalizedKey),
+      transport: 'post',
+    };
   }
 }
 
-export async function checkProLicense() {
+export async function checkProLicense(options = {}) {
   // Returns: { licensed: boolean, key: string|null, source: 'stored'|'none' }
-  const stored = readStoredLicense();
-  if (stored && isValidFormat(stored)) {
-    return { licensed: true, key: stored, source: 'stored' };
+  const record = readStoredLicense();
+  if (!record || !isValidFormat(record.key)) {
+    return { licensed: false, key: null, source: 'none' };
   }
-  return { licensed: false, key: null, source: 'none' };
+
+  if (record.status === 'grace') {
+    const graceUntil = Date.parse(record.graceUntil || '');
+    if (!Number.isNaN(graceUntil) && graceUntil > Date.now()) {
+      return {
+        licensed: true,
+        key: record.key,
+        source: 'grace',
+        provisional: true,
+        graceUntil: record.graceUntil,
+        needsRevalidation: true,
+      };
+    }
+    return { licensed: false, key: null, source: 'expired_grace', message: 'Temporary grace period expired' };
+  }
+
+  const shouldRefresh = options.revalidate === true || shouldRevalidate(record);
+  if (shouldRefresh) {
+    const refreshed = await validateLicenseRemote(record.key);
+    if (refreshed.valid) {
+      const stored = storeLicense(record.key, {
+        status: 'validated',
+        plan: refreshed.plan || record.plan || 'pro',
+        transport: refreshed.transport,
+        source: 'remote',
+      });
+      return {
+        licensed: true,
+        key: stored.key,
+        source: 'revalidated',
+        provisional: false,
+        validatedAt: stored.validatedAt,
+        needsRevalidation: false,
+      };
+    }
+
+    if (refreshed.transient) {
+      return {
+        licensed: true,
+        key: record.key,
+        source: 'stored',
+        provisional: false,
+        validatedAt: record.validatedAt,
+        needsRevalidation: true,
+        message: refreshed.message,
+      };
+    }
+
+    return { licensed: false, key: null, source: 'invalid', message: refreshed.message || 'License key not recognized' };
+  }
+
+  return {
+    licensed: true,
+    key: record.key,
+    source: record.source || 'stored',
+    provisional: false,
+    validatedAt: record.validatedAt,
+    needsRevalidation: false,
+  };
 }

package/lib/manifest.mjs

@@ -3,6 +3,7 @@ import { join } from 'node:path';
 import { homedir } from 'node:os';
 
 const MANIFEST_NAME = '.alice-manifest.json';
+const PACKAGE_VERSION = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8')).version || '0.0.0';
 
 export function getManifestPath() {
   return join(homedir(), '.openclaw', MANIFEST_NAME);
@@ -18,16 +19,24 @@ export function readManifest() {
 }
 
 export function writeManifest(data) {
+  const existing = readManifest() || {};
+  const now = new Date().toISOString();
   const manifest = {
-    version: '1.0.0',
-    installedAt: data.installedAt || new Date().toISOString(),
-    updatedAt: new Date().toISOString(),
-    tier: data.tier,
-    agents: data.agents,
-    userName: data.userName,
-    userTimezone: data.userTimezone,
-    modelPreset: data.modelPreset,
-    missionControl: data.missionControl || null,
+    ...existing,
+    version: data.version || existing.version || PACKAGE_VERSION,
+    schemaVersion: 2,
+    packageVersion: data.packageVersion || existing.packageVersion || PACKAGE_VERSION,
+    installedAt: data.installedAt || existing.installedAt || now,
+    updatedAt: now,
+    tier: data.tier ?? existing.tier ?? 'starter',
+    agents: Array.isArray(data.agents) ? [...new Set(data.agents)] : (existing.agents || []),
+    userName: data.userName ?? existing.userName ?? null,
+    userTimezone: data.userTimezone ?? existing.userTimezone ?? null,
+    modelPreset: data.modelPreset ?? existing.modelPreset ?? null,
+    missionControl: data.missionControl ?? existing.missionControl ?? null,
+    skills: Array.isArray(data.skills) ? [...new Set(data.skills)] : (existing.skills || []),
+    codingTool: data.codingTool ?? existing.codingTool ?? null,
+    codingSkill: data.codingSkill ?? existing.codingSkill ?? null,
   };
   writeFileSync(getManifestPath(), JSON.stringify(manifest, null, 2) + '\n', 'utf8');
   return manifest;

package/lib/mission-control.mjs

@@ -53,6 +53,10 @@ export function buildMissionControlSettings(input = {}) {
   const sourceNode = String(input.sourceNode || hostname() || 'openclaw-local').trim();
   const ingestToken = String(input.ingestToken || '').trim();
   const workerToken = String(input.workerToken || ingestToken || '').trim();
+  const teamId = String(input.teamId || '').trim();
+  const teamSlug = String(input.teamSlug || '').trim();
+  const teamName = String(input.teamName || '').trim();
+  const teamPlan = String(input.teamPlan || '').trim();
 
   return {
     enabled: input.enabled !== false,
@@ -66,6 +70,10 @@ export function buildMissionControlSettings(input = {}) {
     nodeRegisterUrl,
     nodeHeartbeatUrl,
     sourceNode,
+    ...(teamId ? { teamId } : {}),
+    ...(teamSlug ? { teamSlug } : {}),
+    ...(teamName ? { teamName } : {}),
+    ...(teamPlan ? { teamPlan } : {}),
     ...(ingestToken ? { ingestToken } : {}),
     ...(workerToken ? { workerToken } : {}),
   };
@@ -154,6 +162,10 @@ export function configureMissionControlCloud(input = {}) {
       runtimeBaseUrl: settings.runtimeBaseUrl,
       adminHeartbeatUrl: settings.adminHeartbeatUrl,
       sourceNode: settings.sourceNode,
+      teamId: settings.teamId ?? null,
+      teamSlug: settings.teamSlug ?? null,
+      teamName: settings.teamName ?? null,
+      teamPlan: settings.teamPlan ?? null,
       hasIngestToken: !!settings.ingestToken,
       hasWorkerToken: !!settings.workerToken,
     },

package/lib/release-guard.mjs

@@ -0,0 +1,131 @@
+import { execFileSync } from 'node:child_process';
+import { existsSync, readFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const DEFAULT_REPO_ROOT = join(__dirname, '..');
+
+export function readPackageVersion(repoRoot = DEFAULT_REPO_ROOT) {
+  const packagePath = join(repoRoot, 'package.json');
+  const pkg = JSON.parse(readFileSync(packagePath, 'utf8'));
+  return String(pkg.version || '').trim();
+}
+
+export function getExpectedTag(version) {
+  return `v${version}`;
+}
+
+function git(repoRoot, args) {
+  return execFileSync('git', args, {
+    cwd: repoRoot,
+    encoding: 'utf8',
+    stdio: ['ignore', 'pipe', 'pipe'],
+  }).trim();
+}
+
+export function getTagsOnHead(repoRoot = DEFAULT_REPO_ROOT) {
+  const output = git(repoRoot, ['tag', '--points-at', 'HEAD']);
+  return output ? output.split('\n').map((line) => line.trim()).filter(Boolean) : [];
+}
+
+export function hasChangelogEntry(repoRoot, version) {
+  const changelogPath = join(repoRoot, 'landing', 'content', 'changelog.md');
+  if (!existsSync(changelogPath)) return false;
+  const changelog = readFileSync(changelogPath, 'utf8');
+  return changelog.includes(`## v${version} — `);
+}
+
+export function getReleaseNotePath(repoRoot, version) {
+  return join(repoRoot, 'releases', `v${version}.md`);
+}
+
+export function getReleaseNoteChecks(repoRoot, version) {
+  const releaseNotePath = getReleaseNotePath(repoRoot, version);
+  if (!existsSync(releaseNotePath)) {
+    return {
+      exists: false,
+      hasTitle: false,
+      approved: false,
+      hasAnnouncementSection: false,
+      hasChannelsSection: false,
+      path: releaseNotePath,
+    };
+  }
+
+  const content = readFileSync(releaseNotePath, 'utf8');
+  return {
+    exists: true,
+    hasTitle: new RegExp(`^#\\s+v${version}\\b`, 'm').test(content),
+    approved: /^Status:\s*approved\s*$/im.test(content),
+    hasAnnouncementSection: /^##\s+Announcement\s*$/im.test(content),
+    hasChannelsSection: /^##\s+Channels\s*$/im.test(content),
+    path: releaseNotePath,
+  };
+}
+
+export function collectReleaseIssues(repoRoot = DEFAULT_REPO_ROOT) {
+  const version = readPackageVersion(repoRoot);
+  const expectedTag = getExpectedTag(version);
+  const issues = [];
+
+  if (!version) {
+    issues.push('package.json is missing a version.');
+    return issues;
+  }
+
+  const tagsOnHead = getTagsOnHead(repoRoot);
+  if (!tagsOnHead.includes(expectedTag)) {
+    issues.push(`HEAD is missing the matching git tag ${expectedTag}.`);
+  }
+
+  if (!hasChangelogEntry(repoRoot, version)) {
+    issues.push(`landing/content/changelog.md is missing the v${version} entry.`);
+  }
+
+  const releaseNote = getReleaseNoteChecks(repoRoot, version);
+  if (!releaseNote.exists) {
+    issues.push(`Missing release brief: releases/v${version}.md.`);
+  } else {
+    if (!releaseNote.hasTitle) {
+      issues.push(`releases/v${version}.md is missing the '# v${version}' title.`);
+    }
+    if (!releaseNote.approved) {
+      issues.push(`releases/v${version}.md must include 'Status: approved' before publish.`);
+    }
+    if (!releaseNote.hasAnnouncementSection) {
+      issues.push(`releases/v${version}.md is missing the '## Announcement' section.`);
+    }
+    if (!releaseNote.hasChannelsSection) {
+      issues.push(`releases/v${version}.md is missing the '## Channels' section.`);
+    }
+  }
+
+  return issues;
+}
+
+export function runReleaseGuard(repoRoot = DEFAULT_REPO_ROOT) {
+  const version = readPackageVersion(repoRoot);
+  const issues = collectReleaseIssues(repoRoot);
+
+  if (issues.length) {
+    const formatted = issues.map((issue) => `- ${issue}`).join('\n');
+    throw new Error(
+      `Release guard blocked publish for v${version}.\n${formatted}\n\n` +
+        'Fix the release brief, changelog, and git tag before running npm publish again.',
+    );
+  }
+
+  return `Release guard passed for v${version}.`;
+}
+
+const isEntrypoint = process.argv[1] && fileURLToPath(import.meta.url) === process.argv[1];
+
+if (isEntrypoint) {
+  try {
+    console.log(runReleaseGuard());
+  } catch (error) {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+}

package/lib/skills.mjs

@@ -51,7 +51,6 @@ export const SKILL_CATALOG = [
     skills: [
       { id: 'github',       label: 'GitHub',            desc: 'Issues, PRs, CI via gh CLI' },
       { id: 'gh-issues',    label: 'GitHub Issues Bot', desc: 'Auto-fix issues and open PRs' },
-      { id: 'coding-agent', label: 'Coding Agent',      desc: 'Delegate tasks to Codex / Claude Code' },
       { id: '1password',    label: '1Password',         desc: 'Secrets and credentials via op CLI' },
     ],
   },

package/lib/workspace-scaffolder.mjs

@@ -2,6 +2,7 @@ import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'node:fs';
 import { join, dirname } from 'node:path';
 import { homedir } from 'node:os';
 import { fileURLToPath } from 'node:url';
+import { buildCodingAgentSkillContent, resolveCodingAgentPreference } from './coding-agent.mjs';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const TEMPLATES_DIR = join(__dirname, '..', 'templates', 'workspaces');
@@ -100,23 +101,17 @@ export function scaffoldWorkspace(agent, userInfo, agentCount) {
   return { workspaceDir, written, skipped };
 }
 
-export function scaffoldSkills() {
-  // Install the claude-code skill into ~/.openclaw/skills/
-  const claudeCodeSkillDir = join(SKILLS_DIR, 'claude-code');
-  mkdirSync(claudeCodeSkillDir, { recursive: true });
+export function scaffoldSkills(preference = null) {
+  const codingAgentPreference = preference || resolveCodingAgentPreference();
+  const codingAgentSkillDir = join(SKILLS_DIR, codingAgentPreference.skillId);
+  mkdirSync(codingAgentSkillDir, { recursive: true });
 
-  const skillTemplatePath = join(__dirname, '..', 'templates', 'skills', 'claude-code', 'SKILL.md');
-  const skillDestPath = join(claudeCodeSkillDir, 'SKILL.md');
-
-  if (existsSync(skillTemplatePath)) {
-    const content = readFileSync(skillTemplatePath, 'utf8');
-    writeFileSync(skillDestPath, content, 'utf8');
-    return true;
-  }
-  return false;
+  const skillDestPath = join(codingAgentSkillDir, 'SKILL.md');
+  writeFileSync(skillDestPath, buildCodingAgentSkillContent(codingAgentPreference), 'utf8');
+  return codingAgentPreference;
 }
 
-export function scaffoldAll(agents, userInfo) {
+export function scaffoldAll(agents, userInfo, skillPreference = null) {
   const agentCount = agents.length;
   const results = [];
 
@@ -126,7 +121,7 @@ export function scaffoldAll(agents, userInfo) {
   }
 
   // Install skills
-  scaffoldSkills();
+  const installedSkill = scaffoldSkills(skillPreference);
 
-  return results;
+  return { workspaces: results, installedSkill };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@robbiesrobotics/alice-agents",
-  "version": "1.4.5",
+  "version": "1.4.7",
   "description": "A.L.I.C.E. — 28 AI agents for OpenClaw. One conversation, one team.",
   "bin": {
     "alice-agents": "bin/alice-install.mjs"
@@ -23,15 +23,17 @@
     "tools/",
     "snapshots/",
     "templates/agents-starter.json",
+    "templates/agents-pro.json",
     "templates/mission-control-bridge/",
     "templates/skills/",
     "templates/workspaces/",
-    "SELF-HEALING-SPEC.md",
     "README.md"
   ],
   "scripts": {
     "test": "node --test test/*.test.mjs",
-    "test:check": "node --check lib/*.mjs bin/*.mjs"
+    "test:check": "node --check lib/*.mjs bin/*.mjs",
+    "release:check": "node lib/release-guard.mjs",
+    "prepublishOnly": "npm test && npm run test:check && npm run release:check"
   },
   "publishConfig": {
     "access": "public"