@pellux/goodvibes-agent 0.1.69 → 0.1.71

package/src/input/commands/settings-sync-runtime.ts

@@ -1,197 +0,0 @@
-import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
-import { dirname, resolve } from 'node:path';
-import {
-  applySettingsSyncBundle,
-  clearManagedSettingLock,
-  exportSettingsSyncBundle,
-  formatResolvedSettingReview,
-  resolveSettingsSyncConflict,
-  formatStagedManagedBundleReview,
-  formatSettingsControlPlaneReview,
-  getSettingsControlPlaneSnapshot,
-  inspectSettingsSyncBundle,
-  recordSettingsSyncEvent,
-  recordSettingsSyncFailure,
-  setManagedSettingLock,
-  type SettingsSyncBundle,
-} from '@/runtime/index.ts';
-import { getProviderIdFromModel } from '../../config/provider-model.ts';
-import { type ConfigKey } from '../../config/index.ts';
-import { CONFIG_KEYS } from '@pellux/goodvibes-sdk/platform/config';
-import type { CommandRegistry } from '../command-registry.ts';
-import { openCommandPanel, requireShellPaths } from './runtime-services.ts';
-import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils';
-import { requireYesFlag, stripYesFlag } from './confirmation.ts';
-
-export function registerSettingsSyncRuntimeCommands(registry: CommandRegistry): void {
-  registry.register({
-    name: 'settingssync',
-    aliases: ['settings-sync'],
-    description: 'Review sync posture, export/import settings-sync bundles, and open the settings sync workspace',
-    usage: '[review|panel|show <key>|staged|conflicts|resolve <key> <local|synced> --yes|failures|rollback-history|export <path> --yes|inspect <path>|pull <path> --yes|push <path> --yes|lock <key> <source> <reason...> --yes|unlock <key> --yes]',
-    handler(args, ctx) {
-      const parsed = stripYesFlag(args);
-      const commandArgs = [...parsed.rest];
-      const shellPaths = requireShellPaths(ctx);
-      const controlPlaneConfigDir = ctx.platform.configManager.getControlPlaneConfigDir();
-      const sub = (commandArgs[0] ?? 'review').toLowerCase();
-      if (sub === 'panel' || sub === 'open') {
-        openCommandPanel(ctx, 'settings-sync');
-        return;
-      }
-      if (sub === 'show') {
-        const key = commandArgs[1] as ConfigKey | undefined;
-        if (!key || !CONFIG_KEYS.has(key)) {
-          ctx.print('Usage: /settingssync show <config-key>');
-          return;
-        }
-        ctx.print(formatResolvedSettingReview(ctx.platform.configManager, key));
-        return;
-      }
-      if (sub === 'staged') {
-        ctx.print(formatStagedManagedBundleReview(ctx.platform.configManager));
-        return;
-      }
-      if (sub === 'conflicts') {
-        const snapshot = getSettingsControlPlaneSnapshot(ctx.platform.configManager);
-        ctx.print(snapshot.conflicts.length > 0
-          ? [
-              'Settings Sync Conflicts',
-              ...snapshot.conflicts.map((conflict) => `  ${conflict.key}  source=${conflict.source}  path=${conflict.path}`),
-            ].join('\n')
-          : 'Settings Sync Conflicts\n  No settings conflicts recorded.');
-        return;
-      }
-      if (sub === 'resolve') {
-        const key = commandArgs[1] as ConfigKey | undefined;
-        const resolution = (commandArgs[2] ?? '').toLowerCase();
-        if (!key || !CONFIG_KEYS.has(key) || (resolution !== 'local' && resolution !== 'synced')) {
-          ctx.print('Usage: /settingssync resolve <config-key> <local|synced> --yes');
-          return;
-        }
-        if (!parsed.yes) {
-          requireYesFlag(ctx, `resolve synced conflict for ${key}`, '/settingssync resolve <config-key> <local|synced> --yes');
-          return;
-        }
-        const changed = resolveSettingsSyncConflict(ctx.platform.configManager, key, resolution);
-        if (!changed) {
-          ctx.print(`No synced conflict found for ${key}.`);
-          return;
-        }
-        ctx.session.runtime.model = String(ctx.platform.configManager.get('provider.model'));
-        ctx.session.runtime.provider = getProviderIdFromModel(ctx.platform.configManager.get('provider.model'));
-        ctx.session.runtime.reasoningEffort = ctx.platform.configManager.get('provider.reasoningEffort') as string;
-        ctx.print(`Resolved synced conflict for ${key} using the ${resolution} value.`);
-        return;
-      }
-      if (sub === 'failures') {
-        const snapshot = getSettingsControlPlaneSnapshot(ctx.platform.configManager);
-        ctx.print(snapshot.recentFailures.length > 0
-          ? [
-              'Settings Sync Failures',
-              ...snapshot.recentFailures.map((failure) => `  ${failure.surface}  ${failure.message}`),
-            ].join('\n')
-          : 'Settings Sync Failures\n  No recent sync or managed-setting failures recorded.');
-        return;
-      }
-      if (sub === 'rollback-history') {
-        const snapshot = getSettingsControlPlaneSnapshot(ctx.platform.configManager);
-        ctx.print(snapshot.rollbackHistory.length > 0
-          ? [
-              'Managed Rollback History',
-              ...snapshot.rollbackHistory.map((entry) => (
-                `  ${entry.token}  ${entry.profileName}  restored=${entry.restoredKeys.length}  ${new Date(entry.appliedAt).toLocaleString()}`
-              )),
-            ].join('\n')
-          : 'Managed Rollback History\n  No managed apply rollback records yet.');
-        return;
-      }
-      if (sub === 'export' || sub === 'push') {
-        const pathArg = commandArgs[1];
-        if (!pathArg) {
-          ctx.print(`Usage: /settingssync ${sub} <path> --yes`);
-          return;
-        }
-        if (!parsed.yes) {
-          requireYesFlag(ctx, `${sub === 'push' ? 'push' : 'export'} settings sync bundle to ${pathArg}`, `/settingssync ${sub} <path> --yes`);
-          return;
-        }
-        const targetPath = shellPaths.resolveWorkspacePath(pathArg);
-        const bundle = exportSettingsSyncBundle(ctx.platform.configManager);
-        mkdirSync(dirname(targetPath), { recursive: true });
-        writeFileSync(targetPath, JSON.stringify(bundle, null, 2) + '\n', 'utf-8');
-        recordSettingsSyncEvent({
-          surface: 'settings-sync',
-          direction: sub === 'push' ? 'push' : 'export',
-          path: targetPath,
-          timestamp: Date.now(),
-          detail: `${Object.keys(bundle.settings).length} settings exported`,
-        }, controlPlaneConfigDir);
-        ctx.print(`Settings sync bundle exported to ${targetPath}`);
-        return;
-      }
-      if (sub === 'inspect') {
-        const pathArg = commandArgs[1];
-        if (!pathArg) {
-          ctx.print('Usage: /settingssync inspect <path>');
-          return;
-        }
-        const sourcePath = shellPaths.resolveWorkspacePath(pathArg);
-        const bundle = JSON.parse(readFileSync(sourcePath, 'utf-8')) as SettingsSyncBundle;
-        ctx.print(inspectSettingsSyncBundle(bundle));
-        return;
-      }
-      if (sub === 'pull') {
-        const pathArg = commandArgs[1];
-        if (!pathArg) {
-          ctx.print('Usage: /settingssync pull <path> --yes');
-          return;
-        }
-        if (!parsed.yes) {
-          requireYesFlag(ctx, `pull settings sync bundle from ${pathArg}`, '/settingssync pull <path> --yes');
-          return;
-        }
-        const sourcePath = shellPaths.resolveWorkspacePath(pathArg);
-        try {
-          const bundle = JSON.parse(readFileSync(sourcePath, 'utf-8')) as SettingsSyncBundle;
-          const result = applySettingsSyncBundle(ctx.platform.configManager, bundle, sourcePath);
-          ctx.print(`Settings sync bundle pulled from ${sourcePath} (${result.appliedCount} applied, ${result.conflictCount} conflicts).`);
-        } catch (error) {
-          recordSettingsSyncFailure('settings-sync', summarizeError(error), controlPlaneConfigDir);
-          ctx.print(summarizeError(error));
-        }
-        return;
-      }
-      if (sub === 'lock') {
-        const key = commandArgs[1] as ConfigKey | undefined;
-        const source = commandArgs[2];
-        const reason = commandArgs.slice(3).join(' ').trim();
-        if (!key || !source || !reason || !CONFIG_KEYS.has(key)) {
-          ctx.print('Usage: /settingssync lock <config-key> <source> <reason...> --yes');
-          return;
-        }
-        if (!parsed.yes) {
-          requireYesFlag(ctx, `lock managed setting ${key}`, '/settingssync lock <config-key> <source> <reason...> --yes');
-          return;
-        }
-        setManagedSettingLock(key, source, reason, controlPlaneConfigDir);
-        ctx.print(`Managed lock recorded for ${key}.`);
-        return;
-      }
-      if (sub === 'unlock') {
-        const key = commandArgs[1] as ConfigKey | undefined;
-        if (!key || !CONFIG_KEYS.has(key)) {
-          ctx.print('Usage: /settingssync unlock <config-key> --yes');
-          return;
-        }
-        if (!parsed.yes) {
-          requireYesFlag(ctx, `unlock managed setting ${key}`, '/settingssync unlock <config-key> --yes');
-          return;
-        }
-        ctx.print(clearManagedSettingLock(key, controlPlaneConfigDir) ? `Managed lock cleared for ${key}.` : `No managed lock found for ${key}.`);
-        return;
-      }
-      ctx.print(formatSettingsControlPlaneReview(ctx.platform.configManager).join('\n'));
-    },
-  });
-}

package/src/input/commands/share-runtime.ts

@@ -1,127 +0,0 @@
-import { writeFile } from 'node:fs/promises';
-import { resolve } from 'path';
-import type { CommandRegistry } from '../command-registry.ts';
-import {
-  type ExportMessage,
-  defaultExportPath,
-  exportToHTML,
-  exportToJSON,
-  exportToMarkdownExtended,
-} from '@pellux/goodvibes-sdk/platform/export';
-import { logger } from '@pellux/goodvibes-sdk/platform/utils';
-import { requireShellPaths } from './runtime-services.ts';
-import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils';
-import { requireYesFlag, stripYesFlag } from './confirmation.ts';
-
-export function registerShareRuntimeCommands(registry: CommandRegistry): void {
-  registry.register({
-    name: 'share',
-    aliases: [],
-    description: 'Export the current session to a shareable format (html, json, md)',
-    usage: '<html|json|md> [path] [--redact] --yes',
-    argsHint: '<html|json|md> [path]',
-    async handler(args, ctx) {
-      const parsed = stripYesFlag(args);
-      const commandArgs = [...parsed.rest];
-      const shellPaths = requireShellPaths(ctx);
-      const FORMATS = ['html', 'json', 'md'] as const;
-      type Format = typeof FORMATS[number];
-
-      const format = commandArgs[0]?.toLowerCase() as Format | undefined;
-      if (!format || !FORMATS.includes(format)) {
-        ctx.print(
-          'Usage: /share <html|json|md> [path] [--redact] --yes\n'
-          + '  html  — self-contained HTML with syntax highlighting\n'
-          + '  json  — structured JSON (machine-readable)\n'
-          + '  md    — Markdown\n\n'
-          + 'Options:\n'
-          + '  --redact  Redact API keys and personal paths from output\n\n'
-          + 'Default path: ~/goodvibes-exports/session-<timestamp>.<ext>',
-        );
-        return;
-      }
-
-      const remainingArgs = commandArgs.slice(1);
-      const redact = remainingArgs.includes('--redact');
-      const pathArgs = remainingArgs.filter(a => a !== '--redact');
-      const outputPath = pathArgs.length > 0
-        ? shellPaths.resolveWorkspacePath(pathArgs[0])
-        : defaultExportPath(format, shellPaths.homeDirectory);
-
-      if (!parsed.yes) {
-        requireYesFlag(ctx, `export ${format.toUpperCase()} session to ${outputPath}`, '/share <html|json|md> [path] [--redact] --yes');
-        return;
-      }
-
-      const convData = ctx.session.conversationManager.toJSON() as {
-        messages: Array<{
-          role: string;
-          content: unknown;
-          toolCalls?: Array<{ id: string; name: string; arguments: Record<string, unknown> }>;
-          callId?: string;
-          toolName?: string;
-          reasoningContent?: string;
-          reasoningSummary?: string;
-          usage?: {
-            inputTokens: number;
-            outputTokens: number;
-            cacheReadTokens?: number;
-            cacheWriteTokens?: number;
-          };
-          cancelled?: boolean;
-        }>;
-      };
-
-      if (!convData.messages || convData.messages.length === 0) {
-        ctx.print('Nothing to export — conversation is empty.');
-        return;
-      }
-
-      const messages: ExportMessage[] = convData.messages.map(m => ({
-        role: m.role as ExportMessage['role'],
-        content: m.content as string,
-        toolCalls: m.toolCalls,
-        callId: m.callId,
-        toolName: m.toolName,
-        reasoningContent: m.reasoningContent,
-        reasoningSummary: m.reasoningSummary,
-        usage: m.usage,
-        cancelled: m.cancelled,
-      }));
-      const metadata = {
-        model: ctx.session.runtime.model,
-        provider: ctx.session.runtime.provider,
-        sessionId: ctx.session.runtime.sessionId,
-        title: ctx.session.conversationManager.title || undefined,
-      };
-      const options = { redact };
-
-      let outputContent: string;
-      try {
-        if (format === 'html') outputContent = exportToHTML(messages, metadata, options);
-        else if (format === 'json') outputContent = exportToJSON(messages, metadata, options);
-        else outputContent = exportToMarkdownExtended(messages, metadata, options);
-      } catch (err) {
-        ctx.print(`Export failed: ${summarizeError(err)}`);
-        return;
-      }
-
-      const { mkdirSync } = await import('node:fs');
-      const { dirname } = await import('node:path');
-      try {
-        mkdirSync(dirname(outputPath), { recursive: true });
-      } catch (mkdirErr) {
-        logger.warn(`[share] mkdir failed for ${dirname(outputPath)}:`, mkdirErr instanceof Error ? { message: mkdirErr.message } : undefined);
-      }
-
-      try {
-        await writeFile(outputPath, outputContent, 'utf-8');
-      } catch (err) {
-        ctx.print(`Failed to write export: ${summarizeError(err)}`);
-        return;
-      }
-
-      ctx.print(`Exported ${format.toUpperCase()} session to ${outputPath}${redact ? ' (sensitive data redacted)' : ''}`);
-    },
-  });
-}

package/src/input/commands/skills-runtime.ts

@@ -1,226 +0,0 @@
-import type { CommandRegistry } from '../command-registry.ts';
-import { discoverSkills } from '../../panels/skills-panel.ts';
-import {
-  installEcosystemCatalogEntry,
-  listInstalledEcosystemEntries,
-  loadEcosystemCatalog,
-  removeEcosystemCatalogEntry,
-  reviewEcosystemCatalogEntry,
-  searchEcosystemCatalog,
-  uninstallEcosystemCatalogEntry,
-  updateInstalledEcosystemEntry,
-  upsertEcosystemCatalogEntry,
-} from '@/runtime/index.ts';
-import { requireEcosystemCatalogPaths, requirePanelManager, requireShellPaths } from './runtime-services.ts';
-import { runAgentSkillsRuntimeCommand } from './agent-skills-runtime.ts';
-
-export function registerSkillsRuntimeCommands(registry: CommandRegistry): void {
-  registry.register({
-    name: 'skills',
-    aliases: ['skill'],
-    description: 'Inspect installed skill packs',
-    usage: '[open|local ...|list|show <name>|origins|browse [query]|installed|catalog-review <id>|publish-local <id> <path> <summary...>|unpublish <id>|install-hint <catalog-id>|install <id> [project|user]|update <id> [project|user]|uninstall <id> [project|user]]',
-    async handler(args, ctx) {
-      const sub = args[0] ?? 'open';
-      if (sub === 'local' || sub === 'agent') {
-        await runAgentSkillsRuntimeCommand(args.slice(1), ctx);
-        return;
-      }
-      if (sub === 'open' || sub === 'panel') {
-        if (ctx.showPanel) ctx.showPanel('skills');
-        else {
-          const panelManager = requirePanelManager(ctx);
-          panelManager.open('skills');
-          panelManager.show();
-          ctx.renderRequest();
-        }
-        return;
-      }
-      const skills = await discoverSkills(requireShellPaths(ctx));
-      const ecosystemPaths = requireEcosystemCatalogPaths(ctx);
-      if (sub === 'list') {
-        if (skills.length === 0) {
-          ctx.print('No skills discovered.');
-          return;
-        }
-        ctx.print([
-          `Skills (${skills.length})`,
-          ...skills.map((skill) => `  ${skill.name}  [${skill.origin}]  ${skill.description || 'No description provided.'}`),
-        ].join('\n'));
-        return;
-      }
-      if (sub === 'origins') {
-        const counts = new Map<string, number>();
-        for (const skill of skills) counts.set(skill.origin, (counts.get(skill.origin) ?? 0) + 1);
-        ctx.print([
-          'Skill Origins',
-          ...[...counts.entries()].map(([origin, count]) => `  ${origin}: ${count}`),
-        ].join('\n'));
-        return;
-      }
-      if (sub === 'show') {
-        const name = args[1];
-        if (!name) {
-          ctx.print('Usage: /skills show <name>');
-          return;
-        }
-        const skill = skills.find((entry) => entry.name === name);
-        if (!skill) {
-          ctx.print(`Unknown skill: ${name}`);
-          return;
-        }
-        ctx.print([
-          `Skill ${skill.name}`,
-          `  origin: ${skill.origin}`,
-          `  path: ${skill.path}`,
-          `  description: ${skill.description || 'No description provided.'}`,
-          `  dependencies: ${skill.dependencies.join(', ') || '(none)'}`,
-          `  includes: ${skill.includes.join(', ') || '(none)'}`,
-        ].join('\n'));
-        return;
-      }
-      if (sub === 'browse' || sub === 'catalog') {
-        const query = args.slice(1).join(' ');
-        const entries = query ? searchEcosystemCatalog('skill', query, ecosystemPaths) : loadEcosystemCatalog('skill', ecosystemPaths);
-        if (entries.length === 0) {
-          ctx.print(query
-            ? `No curated skill catalog entries matched "${query}".`
-            : 'No curated skill catalog entries found. Add .goodvibes/agent/ecosystem/skills.json to publish a local-first skill catalog.');
-          return;
-        }
-        ctx.print([
-          `Curated Skill Catalog (${entries.length})`,
-          ...entries.map((entry) => `  ${entry.id}  ${entry.name}  [${entry.tags.join(', ') || 'untagged'}]  ${entry.summary}`),
-        ].join('\n'));
-        return;
-      }
-      if (sub === 'installed') {
-        const receipts = listInstalledEcosystemEntries('skill', ecosystemPaths);
-        if (receipts.length === 0) {
-          ctx.print('No curated skills installed from local catalogs yet.');
-          return;
-        }
-        ctx.print([
-          `Installed Curated Skills (${receipts.length})`,
-          ...receipts.map((receipt) => `  ${receipt.entry.id}  ${receipt.scope}  ${receipt.targetPath}`),
-        ].join('\n'));
-        return;
-      }
-      if (sub === 'catalog-review') {
-        const entryId = args[1];
-        if (!entryId) {
-          ctx.print('Usage: /skills catalog-review <catalog-id>');
-          return;
-        }
-        const entry = loadEcosystemCatalog('skill', ecosystemPaths).find((candidate) => candidate.id === entryId);
-        if (!entry) {
-          ctx.print(`Unknown curated skill entry: ${entryId}`);
-          return;
-        }
-        const review = reviewEcosystemCatalogEntry(entry, ecosystemPaths);
-        ctx.print([
-          `Skill Catalog Review: ${entry.name}`,
-          `  id: ${entry.id}`,
-          `  source: ${entry.source}`,
-          `  sourceKind: ${review.sourceKind}`,
-          `  sourceExists: ${review.sourceExists ? 'yes' : 'no'}`,
-          `  recommendedScope: ${review.recommendedScope}`,
-          `  risk: ${review.riskLevel}`,
-          `  trust notes: ${entry.trustNotes ?? '(none)'}`,
-          `  provenance: ${entry.provenance ?? '(none)'}`,
-          `  update hint: ${entry.updateHint ?? '(none)'}`,
-        ].join('\n'));
-        return;
-      }
-      if (sub === 'publish-local') {
-        const entryId = args[1];
-        const sourcePath = args[2];
-        const summary = args.slice(3).join(' ').trim();
-        if (!entryId || !sourcePath || !summary) {
-          ctx.print('Usage: /skills publish-local <catalog-id> <path> <summary...>');
-          return;
-        }
-        const result = upsertEcosystemCatalogEntry({
-          id: entryId,
-          kind: 'skill',
-          name: entryId.replace(/[-_]/g, ' ').replace(/\b\w/g, (char) => char.toUpperCase()),
-          summary,
-          source: sourcePath,
-          tags: ['local-first', 'published'],
-          provenance: 'operator-published',
-          updateHint: 'Use /skills publish-local again to refresh catalog metadata after edits.',
-        }, ecosystemPaths);
-        ctx.print(result.ok ? `Published curated skill ${entryId} into ${result.path}` : `Error: ${result.error}`);
-        return;
-      }
-      if (sub === 'unpublish') {
-        const entryId = args[1];
-        if (!entryId) {
-          ctx.print('Usage: /skills unpublish <catalog-id>');
-          return;
-        }
-        const result = removeEcosystemCatalogEntry('skill', entryId, ecosystemPaths);
-        ctx.print(result.ok ? `Removed curated skill ${entryId} from ${result.path}` : `Error: ${result.error}`);
-        return;
-      }
-      if (sub === 'install-hint') {
-        const entryId = args[1];
-        if (!entryId) {
-          ctx.print('Usage: /skills install-hint <catalog-id>');
-          return;
-        }
-        const entry = loadEcosystemCatalog('skill', ecosystemPaths).find((candidate) => candidate.id === entryId);
-        if (!entry) {
-          ctx.print(`Unknown curated skill entry: ${entryId}`);
-          return;
-        }
-        ctx.print([
-          `Skill Install Guidance: ${entry.name}`,
-          `  id: ${entry.id}`,
-          `  source: ${entry.source}`,
-          `  tags: ${entry.tags.join(', ') || '(none)'}`,
-          `  trust notes: ${entry.trustNotes ?? '(none)'}`,
-          `  install hint: ${entry.installHint ?? 'Place the skill pack under a configured skill directory and refresh the skills panel.'}`,
-        ].join('\n'));
-        return;
-      }
-      if (sub === 'install') {
-        const entryId = args[1];
-        const scopeArg = args[2];
-        if (!entryId) {
-          ctx.print('Usage: /skills install <catalog-id> [project|user]');
-          return;
-        }
-        const scope = scopeArg === 'project' ? 'project' : 'user';
-        const result = installEcosystemCatalogEntry('skill', entryId, { ...ecosystemPaths, scope });
-        ctx.print(result.ok ? `Installed curated skill ${entryId} into ${result.receipt.targetPath}` : `Error: ${result.error}`);
-        return;
-      }
-      if (sub === 'update') {
-        const entryId = args[1];
-        const scopeArg = args[2];
-        if (!entryId) {
-          ctx.print('Usage: /skills update <catalog-id> [project|user]');
-          return;
-        }
-        const scope = scopeArg === 'project' ? 'project' : 'user';
-        const result = updateInstalledEcosystemEntry('skill', entryId, { ...ecosystemPaths, scope });
-        ctx.print(result.ok ? `Updated curated skill ${entryId} in ${result.receipt.targetPath}` : `Error: ${result.error}`);
-        return;
-      }
-      if (sub === 'uninstall') {
-        const entryId = args[1];
-        const scopeArg = args[2];
-        if (!entryId) {
-          ctx.print('Usage: /skills uninstall <catalog-id> [project|user]');
-          return;
-        }
-        const scope = scopeArg === 'project' ? 'project' : 'user';
-        const result = uninstallEcosystemCatalogEntry('skill', entryId, { ...ecosystemPaths, scope });
-        ctx.print(result.ok ? `Uninstalled curated skill ${entryId} from ${result.removedPath}` : `Error: ${result.error}`);
-        return;
-      }
-      ctx.print('Usage: /skills [open|local ...|list|show <name>|origins|browse [query]|installed|catalog-review <id>|publish-local <id> <path> <summary...>|unpublish <id>|install-hint <catalog-id>|install <id> [project|user]|update <id> [project|user]|uninstall <id> [project|user]]');
-    },
-  });
-}

package/src/input/commands/teleport-runtime.ts

@@ -1,68 +0,0 @@
-import { readFileSync } from 'node:fs';
-import type { CommandRegistry } from '../command-registry.ts';
-import type { RemoteSessionBundle } from '@/runtime/index.ts';
-import { requirePeerClient, requireShellPaths } from './runtime-services.ts';
-import { requireYesFlag, stripYesFlag } from './confirmation.ts';
-
-function inspectRemoteSessionBundle(bundle: RemoteSessionBundle): string {
-  return [
-    'Teleport Bundle Review',
-    `  session: ${bundle.sessionId}`,
-    `  exportedAt: ${new Date(bundle.exportedAt).toISOString()}`,
-    `  active connections: ${bundle.activeConnectionIds.length}`,
-    `  pools: ${bundle.pools.length}`,
-    `  contracts: ${bundle.contracts.length}`,
-    `  artifacts: ${bundle.artifacts.length}`,
-  ].join('\n');
-}
-
-export function registerTeleportRuntimeCommands(registry: CommandRegistry): void {
-  registry.register({
-    name: 'teleport',
-    description: 'Package, inspect, and import portable remote-session handoff bundles',
-    usage: '[export <path> --yes|inspect <path>|import <path> --yes]',
-    async handler(args, ctx) {
-      const parsed = stripYesFlag(args);
-      const commandArgs = [...parsed.rest];
-      const shellPaths = requireShellPaths(ctx);
-      const mode = (commandArgs[0] ?? 'export').toLowerCase();
-      const pathArg = commandArgs[1];
-      if (!pathArg) {
-        ctx.print('Usage: /teleport [export <path> --yes|inspect <path>|import <path> --yes]');
-        return;
-      }
-      let peerClient;
-      try {
-        peerClient = requirePeerClient(ctx);
-      } catch {
-        ctx.print('Remote worker registry is not available in this runtime.');
-        return;
-      }
-      const targetPath = shellPaths.resolveWorkspacePath(pathArg);
-      if (mode === 'export') {
-        if (!parsed.yes) {
-          requireYesFlag(ctx, `export teleport bundle to ${pathArg}`, '/teleport export <path> --yes');
-          return;
-        }
-        const exported = await peerClient.runners.exportSessionBundle(targetPath);
-        ctx.print(`Teleport bundle exported for session ${exported.bundle.sessionId} to ${exported.path}`);
-        return;
-      }
-      if (mode === 'inspect') {
-        const bundle = JSON.parse(readFileSync(targetPath, 'utf-8')) as RemoteSessionBundle;
-        ctx.print(inspectRemoteSessionBundle(bundle));
-        return;
-      }
-      if (mode === 'import') {
-        if (!parsed.yes) {
-          requireYesFlag(ctx, `import teleport bundle from ${pathArg}`, '/teleport import <path> --yes');
-          return;
-        }
-        const bundle = await peerClient.runners.importSessionBundle(targetPath);
-        ctx.print(`Imported teleport bundle ${bundle.sessionId} with ${bundle.contracts.length} contracts.`);
-        return;
-      }
-      ctx.print('Usage: /teleport [export <path> --yes|inspect <path>|import <path> --yes]');
-    },
-  });
-}