@pellux/goodvibes-agent 1.8.0 → 1.8.2

package/src/cli/import-command.ts

@@ -0,0 +1,208 @@
+import { isAbsolute, resolve } from 'node:path';
+import {
+  MemoryEmbeddingProviderRegistry,
+  MemoryRegistry,
+  MemoryStore,
+  resolveCanonicalMemoryDbPath,
+} from '@pellux/goodvibes-sdk/platform/state';
+import { assertNoSecretLikeMemoryText } from '../agent/memory-safety.ts';
+import { buildAgentSkillRequirements } from '../agent/skill-registry.ts';
+import type { CliCommandOutput } from './types.ts';
+import type { CliCommandRuntime } from './management.ts';
+import { failure, personaRegistry, skillRegistry, success } from './local-library-command-shared.ts';
+import {
+  OPENCLAW_LAYOUT_VERSION,
+  scanOpenClawWorkspace,
+  type OpenClawImportPlan,
+} from './openclaw-import.ts';
+
+/**
+ * `goodvibes-agent import openclaw [path]` — migrate an OpenClaw workspace into
+ * the Agent's existing registries. Dry-run is the DEFAULT (prints what would be
+ * created); --apply performs the writes through the persona registry, the
+ * canonical memory store, the skill registry, and the permission settings. No
+ * parallel storage is invented. See openclaw-import.ts for the targeted layout.
+ */
+
+interface ApplyCounts {
+  created: number;
+  skipped: number;
+}
+
+function resolveSourcePath(runtime: CliCommandRuntime, arg: string | undefined): string {
+  // Home is taken from the runtime's owned home root (the composition root passes
+  // it in), never discovered implicitly. Default workspace is <home>/.openclaw.
+  if (!arg) return resolve(runtime.homeDirectory, '.openclaw');
+  if (arg.startsWith('~')) return resolve(runtime.homeDirectory, arg.slice(1).replace(/^[/\\]/, ''));
+  if (isAbsolute(arg)) return arg;
+  return resolve(runtime.workingDirectory, arg);
+}
+
+function planSummaryLines(plan: OpenClawImportPlan): string[] {
+  const lines: string[] = [];
+  lines.push(`  personas: ${plan.personas.length}`);
+  for (const persona of plan.personas) lines.push(`    - ${persona.name}  (${persona.sourcePath})`);
+  lines.push(`  memory records: ${plan.memories.length}`);
+  for (const memory of plan.memories) lines.push(`    - ${memory.scope}/${memory.cls}  ${memory.summary}`);
+  lines.push(`  skills: ${plan.skills.length}`);
+  for (const skill of plan.skills) lines.push(`    - ${skill.name}  (${skill.sourcePath})`);
+  const perm = plan.permissions;
+  lines.push(`  permission allowlist: ${perm.categories.length} categor${perm.categories.length === 1 ? 'y' : 'ies'}${perm.sourcePath ? ` (${perm.sourcePath})` : ''}`);
+  if (perm.categories.length > 0) lines.push(`    - allow: ${perm.categories.join(', ')}  (mode -> custom)`);
+  lines.push(`  skipped: ${plan.skipped.length}`);
+  for (const entry of plan.skipped) lines.push(`    - ${entry.path}: ${entry.reason}`);
+  return lines;
+}
+
+function renderDryRun(plan: OpenClawImportPlan): string {
+  return [
+    `OpenClaw import (dry run) — layout ${OPENCLAW_LAYOUT_VERSION}`,
+    `  source ${plan.sourcePath}`,
+    ...planSummaryLines(plan),
+    '',
+    '  This is a preview. Re-run with --apply to write these into the Agent registries.',
+  ].join('\n');
+}
+
+async function applyMemories(
+  runtime: CliCommandRuntime,
+  plan: OpenClawImportPlan,
+  notes: string[],
+): Promise<ApplyCounts> {
+  const counts: ApplyCounts = { created: 0, skipped: 0 };
+  if (plan.memories.length === 0) return counts;
+  const path = resolveCanonicalMemoryDbPath(runtime.homeDirectory);
+  const embeddingRegistry = new MemoryEmbeddingProviderRegistry({ configManager: runtime.configManager });
+  const store = new MemoryStore(path, { embeddingRegistry });
+  await store.init();
+  const registry = new MemoryRegistry(store);
+  try {
+    for (const memory of plan.memories) {
+      try {
+        assertNoSecretLikeMemoryText([memory.summary, memory.detail ?? '', ...memory.tags]);
+        await registry.add({
+          scope: memory.scope as 'session' | 'project' | 'team',
+          cls: memory.cls as 'fact',
+          summary: memory.summary,
+          detail: memory.detail,
+          tags: [...memory.tags],
+          provenance: [{ kind: 'event', ref: `openclaw-import:${memory.sourcePath}` }],
+        });
+        counts.created += 1;
+      } catch (error) {
+        counts.skipped += 1;
+        notes.push(`  memory skipped (${memory.summary}): ${error instanceof Error ? error.message : String(error)}`);
+      }
+    }
+  } finally {
+    await store.save();
+    store.close();
+  }
+  return counts;
+}
+
+function applyPersonas(runtime: CliCommandRuntime, plan: OpenClawImportPlan, notes: string[]): ApplyCounts {
+  const counts: ApplyCounts = { created: 0, skipped: 0 };
+  const registry = personaRegistry(runtime);
+  for (const persona of plan.personas) {
+    try {
+      registry.create({
+        name: persona.name,
+        description: persona.description,
+        body: persona.body,
+        tags: [...persona.tags],
+        source: 'imported',
+        provenance: `openclaw-import:${persona.sourcePath}`,
+      });
+      counts.created += 1;
+    } catch (error) {
+      counts.skipped += 1;
+      notes.push(`  persona skipped (${persona.name}): ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  return counts;
+}
+
+function applySkills(runtime: CliCommandRuntime, plan: OpenClawImportPlan, notes: string[]): ApplyCounts {
+  const counts: ApplyCounts = { created: 0, skipped: 0 };
+  const registry = skillRegistry(runtime);
+  for (const skill of plan.skills) {
+    try {
+      registry.create({
+        name: skill.name,
+        description: skill.description,
+        procedure: skill.procedure,
+        tags: [...skill.tags],
+        requirements: buildAgentSkillRequirements({ env: skill.requiresEnv, commands: skill.requiresCommand }),
+        source: 'imported',
+        provenance: `openclaw-import:${skill.sourcePath}`,
+      });
+      counts.created += 1;
+    } catch (error) {
+      counts.skipped += 1;
+      notes.push(`  skill skipped (${skill.name}): ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  return counts;
+}
+
+function applyPermissions(runtime: CliCommandRuntime, plan: OpenClawImportPlan): number {
+  const categories = plan.permissions.categories;
+  if (categories.length === 0) return 0;
+  runtime.configManager.setDynamic('permissions.mode', 'custom');
+  for (const category of categories) {
+    runtime.configManager.setDynamic(`permissions.tools.${category}` as never, 'allow');
+  }
+  return categories.length;
+}
+
+async function renderApply(runtime: CliCommandRuntime, plan: OpenClawImportPlan): Promise<string> {
+  const notes: string[] = [];
+  const personas = applyPersonas(runtime, plan, notes);
+  const memories = await applyMemories(runtime, plan, notes);
+  const skills = applySkills(runtime, plan, notes);
+  const permissionCategories = applyPermissions(runtime, plan);
+  return [
+    `OpenClaw import (applied) — layout ${OPENCLAW_LAYOUT_VERSION}`,
+    `  source ${plan.sourcePath}`,
+    `  personas created ${personas.created}${personas.skipped ? ` (skipped ${personas.skipped})` : ''}`,
+    `  memory records created ${memories.created}${memories.skipped ? ` (skipped ${memories.skipped})` : ''}`,
+    `  skills created ${skills.created}${skills.skipped ? ` (skipped ${skills.skipped})` : ''}`,
+    `  permission categories allowed ${permissionCategories}${permissionCategories ? ` (${plan.permissions.categories.join(', ')}; mode -> custom)` : ''}`,
+    `  input files skipped ${plan.skipped.length}`,
+    ...notes,
+  ].join('\n');
+}
+
+function usageImport(): string {
+  return 'Usage: goodvibes-agent import openclaw [path] [--apply]';
+}
+
+export async function handleImportCommand(runtime: CliCommandRuntime): Promise<CliCommandOutput> {
+  try {
+    const [sourceRaw, ...rest] = runtime.cli.commandArgs;
+    const source = (sourceRaw ?? '').toLowerCase();
+    if (!source) return failure(runtime, 'invalid_import_command', usageImport(), 2);
+    if (source !== 'openclaw') {
+      return failure(runtime, 'unknown_import_source', `Unknown import source "${sourceRaw}". Supported sources: openclaw.\n${usageImport()}`, 2);
+    }
+    const apply = rest.includes('--apply');
+    const pathArg = rest.find((arg) => !arg.startsWith('--'));
+    const sourcePath = resolveSourcePath(runtime, pathArg);
+    const plan = scanOpenClawWorkspace(sourcePath);
+    if (!plan.exists) {
+      const message = pathArg
+        ? `OpenClaw workspace not found at ${sourcePath}.`
+        : `No OpenClaw workspace found at the default location ${sourcePath}. Pass a path: goodvibes-agent import openclaw <path>.`;
+      return failure(runtime, 'openclaw_workspace_missing', message, 1);
+    }
+    if (apply) {
+      const output = await renderApply(runtime, plan);
+      return success(runtime, 'agent.import.openclaw.apply', plan, output);
+    }
+    return success(runtime, 'agent.import.openclaw.dryRun', plan, renderDryRun(plan));
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return failure(runtime, 'agent.import.error', message, 1);
+  }
+}

package/src/cli/index.ts

@@ -7,4 +7,5 @@ export * from './completion.ts';
 export * from './config-overrides.ts';
 export * from './endpoints.ts';
 export * from './bundle-command.ts';
+export * from './import-command.ts';
 export * from './management.ts';

package/src/cli/management-commands.ts

@@ -14,6 +14,7 @@ import { extractAuthorizationCode, formatJsonOrText, hasCommandFlag, openBrowser
 import { GOODVIBES_AGENT_PAIRING_SURFACE } from '../config/surface.ts';
 import { connectedHostTokenRequiredMessage, readConnectedHostOperatorToken } from '../runtime/connected-host-auth.ts';
 import { formatAgentRecordSource } from '../agent/record-labels.ts';
+import { appendTemporalLabel } from './temporal-label.ts';
 
 function resolveManualSubscriptionConfig(config: OAuthProviderConfig): OAuthProviderConfig {
   return config.manualRedirectUri
@@ -58,7 +59,7 @@ export async function renderSubscriptions(runtime: CliCommandRuntime): Promise<s
         ] : []),
         ...(stored ? [
           `  token type ${stored.tokenType}`,
-          `  expires ${stored.expiresAt ? new Date(stored.expiresAt).toISOString() : 'n/a'}`,
+          `  expires ${stored.expiresAt ? appendTemporalLabel(new Date(stored.expiresAt).toISOString(), stored.expiresAt) : 'n/a'}`,
           `  refresh token ${stored.refreshToken ? 'present' : 'absent'}`,
           `  override ambient ${yesNo(stored.overrideAmbientApiKeys)}`,
         ] : ['  stored no']),
@@ -136,7 +137,7 @@ export async function renderSubscriptions(runtime: CliCommandRuntime): Promise<s
         return [
           `Subscription stored ${provider}`,
           `  token type ${record.tokenType}`,
-          `  expires ${record.expiresAt ? new Date(record.expiresAt).toISOString() : 'n/a'}`,
+          `  expires ${record.expiresAt ? appendTemporalLabel(new Date(record.expiresAt).toISOString(), record.expiresAt) : 'n/a'}`,
         ].join('\n');
       }
       const activeConfig = resolveManualSubscriptionConfig(resolved.oauth);
@@ -144,7 +145,7 @@ export async function renderSubscriptions(runtime: CliCommandRuntime): Promise<s
       return [
         `Subscription stored ${provider}`,
         `  token type ${record.tokenType}`,
-        `  expires ${record.expiresAt ? new Date(record.expiresAt).toISOString() : 'n/a'}`,
+        `  expires ${record.expiresAt ? appendTemporalLabel(new Date(record.expiresAt).toISOString(), record.expiresAt) : 'n/a'}`,
       ].join('\n');
     }
     if (sub === 'refresh') {
@@ -155,7 +156,7 @@ export async function renderSubscriptions(runtime: CliCommandRuntime): Promise<s
       const record = await services.subscriptionManager.refreshOAuthToken(provider, resolved.oauth);
       return [
         `Subscription refreshed ${provider}`,
-        `  expires ${record.expiresAt ? new Date(record.expiresAt).toISOString() : 'n/a'}`,
+        `  expires ${record.expiresAt ? appendTemporalLabel(new Date(record.expiresAt).toISOString(), record.expiresAt) : 'n/a'}`,
       ].join('\n');
     }
     if (sub === 'logout' || sub === 'remove') {
@@ -179,9 +180,9 @@ export async function renderSubscriptions(runtime: CliCommandRuntime): Promise<s
     return formatJsonOrText(runtime.cli)(value, [
       'GoodVibes subscriptions',
       subscriptions.length === 0 ? '  active none' : '  active',
-      ...subscriptions.map((sub) => `    ${sub.provider} token ${sub.tokenType} expires ${sub.expiresAt ? new Date(sub.expiresAt).toISOString() : 'n/a'} override ambient ${yesNo(sub.overrideAmbientApiKeys)}`),
+      ...subscriptions.map((sub) => `    ${sub.provider} token ${sub.tokenType} expires ${sub.expiresAt ? appendTemporalLabel(new Date(sub.expiresAt).toISOString(), sub.expiresAt) : 'n/a'} override ambient ${yesNo(sub.overrideAmbientApiKeys)}`),
       pending.length === 0 ? '  pending none' : '  pending',
-      ...pending.map((sub) => `    ${sub.provider} created ${new Date(sub.createdAt).toISOString()}`),
+      ...pending.map((sub) => `    ${sub.provider} created ${appendTemporalLabel(new Date(sub.createdAt).toISOString(), sub.createdAt)}`),
     ].join('\n'));
   });
 }
@@ -268,7 +269,7 @@ export async function handleSessions(runtime: CliCommandRuntime): Promise<string
       const value = sessions;
       return formatJsonOrText(runtime.cli)(value, [
         `GoodVibes sessions (${sessions.length})`,
-        ...sessions.slice(0, 50).map((session) => `  ${session.name}  messages ${session.messageCount}  ${new Date(session.timestamp).toISOString()}  ${session.title || '(untitled)'}`),
+        ...sessions.slice(0, 50).map((session) => `  ${session.name}  messages ${session.messageCount}  ${appendTemporalLabel(new Date(session.timestamp).toISOString(), session.timestamp)}  ${session.title || '(untitled)'}`),
       ].join('\n'));
     }
     if (sub === 'show' || sub === 'info') {
@@ -281,7 +282,7 @@ export async function handleSessions(runtime: CliCommandRuntime): Promise<string
         `  title ${found.title || '(untitled)'}`,
         `  messages ${found.messageCount}`,
         `  provider/model ${found.provider}/${found.model}`,
-        `  updated ${new Date(found.timestamp).toISOString()}`,
+        `  updated ${appendTemporalLabel(new Date(found.timestamp).toISOString(), found.timestamp)}`,
         `  file ${found.filePath}`,
       ].join('\n'));
     }

package/src/cli/management.ts

@@ -27,6 +27,7 @@ import type { GoodVibesCliParseResult } from './types.ts';
 import { formatProviderAuthRoute, summarizeProviderAuthRoutes } from './provider-auth-routes.ts';
 import { classifyProviderSetup } from './provider-classification.ts';
 import { handleBundleCommand } from './bundle-command.ts';
+import { handleImportCommand } from './import-command.ts';
 import { handleSecrets, handleSessions, handleTasks, renderPairing, renderSubscriptions } from './management-commands.ts';
 import { handleAgentKnowledgeCommand, handleAgentKnowledgeShortcutCommand, handleCompatCommand, handleDelegateCommand } from './agent-knowledge-command.ts';
 import { handlePersonasCommand } from './personas-command.ts';
@@ -34,6 +35,12 @@ import { handleSkillsCommand } from './skills-command.ts';
 import { handleMemoryCommand } from './memory-command.ts';
 import { handleProfilesCommand } from './profiles-command.ts';
 import { handleRoutinesCommand } from './routines-command.ts';
+import { handleCiCommand } from './ci-command.ts';
+import { handlePrincipalsCommand } from './principals-command.ts';
+import { handleChannelProfilesCommand } from './channel-profiles-command.ts';
+import { handleWorkspacesCommand } from './workspaces-command.ts';
+import { handleRelayCommand } from './relay-command.ts';
+import { handleFleetCommand } from './fleet-command.ts';
 import { GOODVIBES_AGENT_SURFACE_ROOT } from '../config/surface.ts';
 
 export interface CliCommandRuntime {
@@ -620,6 +627,36 @@ export async function handleGoodVibesCliCommand(runtime: CliCommandRuntime): Pro
         console.log(result.output);
         return { handled: true, exitCode: result.exitCode };
       }
+      case 'ci': {
+        const result = await handleCiCommand(runtime);
+        console.log(result.output);
+        return { handled: true, exitCode: result.exitCode };
+      }
+      case 'principals': {
+        const result = await handlePrincipalsCommand(runtime);
+        console.log(result.output);
+        return { handled: true, exitCode: result.exitCode };
+      }
+      case 'channel-profiles': {
+        const result = await handleChannelProfilesCommand(runtime);
+        console.log(result.output);
+        return { handled: true, exitCode: result.exitCode };
+      }
+      case 'workspaces': {
+        const result = await handleWorkspacesCommand(runtime);
+        console.log(result.output);
+        return { handled: true, exitCode: result.exitCode };
+      }
+      case 'relay': {
+        const result = handleRelayCommand(runtime);
+        console.log(result.output);
+        return { handled: true, exitCode: result.exitCode };
+      }
+      case 'fleet': {
+        const result = await handleFleetCommand(runtime);
+        console.log(result.output);
+        return { handled: true, exitCode: result.exitCode };
+      }
       case 'knowledge': {
         const result = await handleAgentKnowledgeCommand(runtime);
         console.log(result.output);
@@ -665,6 +702,11 @@ export async function handleGoodVibesCliCommand(runtime: CliCommandRuntime): Pro
         console.log(result.output);
         return { handled: true, exitCode: result.exitCode };
       }
+      case 'import': {
+        const result = await handleImportCommand(runtime);
+        console.log(result.output);
+        return { handled: true, exitCode: result.exitCode };
+      }
       default:
         return { handled: false, exitCode: 0 };
     }

package/src/cli/memory-command.ts

@@ -23,6 +23,7 @@ import type { CliCommandRuntime } from './management.ts';
 // Split out to stay under the architecture line cap; see its file header for the
 // CLI ruling on when a memory subcommand goes over the wire vs local-direct.
 import { tryWireMemoryCommand } from './memory-command-wire.ts';
+import { appendTemporalLabel } from './temporal-label.ts';
 
 const VALID_CLASSES: readonly MemoryClass[] = ['decision', 'constraint', 'incident', 'pattern', 'fact', 'risk', 'runbook', 'architecture', 'ownership'];
 const VALID_SCOPES: readonly MemoryScope[] = ['session', 'project', 'team'];
@@ -253,9 +254,9 @@ export function renderRecord(record: MemoryRecord, links: readonly MemoryLink[])
     `  review: ${formatAgentRecordReviewState(record.reviewState)}`,
     `  confidence: ${record.confidence}`,
     `  tags: ${record.tags.join(', ') || '(none)'}`,
-    `  created: ${timestamp(record.createdAt)}`,
-    `  updated: ${timestamp(record.updatedAt)}`,
-    record.reviewedAt ? `  reviewed: ${timestamp(record.reviewedAt)}${record.reviewedBy ? ` by ${record.reviewedBy}` : ''}` : '',
+    `  created: ${appendTemporalLabel(timestamp(record.createdAt), record.createdAt)}`,
+    `  updated: ${appendTemporalLabel(timestamp(record.updatedAt), record.updatedAt)}`,
+    record.reviewedAt ? `  reviewed: ${appendTemporalLabel(timestamp(record.reviewedAt), record.reviewedAt)}${record.reviewedBy ? ` by ${record.reviewedBy}` : ''}` : '',
     record.staleReason ? `  stale reason: ${record.staleReason}` : '',
     '',
     record.summary,