@laitszkin/apollo-toolkit 3.13.2 → 3.14.1

package/dist/lib/tools/sync-memory-index.js

@@ -0,0 +1,113 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.syncMemoryIndexHandler = syncMemoryIndexHandler;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const START_MARKER = '<!-- codex-memory-manager:start -->';
+const END_MARKER = '<!-- codex-memory-manager:end -->';
+const DEFAULT_SECTION_TITLE = '## User Memory Index';
+const DEFAULT_INSTRUCTIONS = [
+    'Before starting work, review the index below and open any relevant user preference files.',
+    'When a new preference category appears, create or update the matching memory file and refresh this index.',
+];
+function titleFromMemoryFile(filePath) {
+    try {
+        const content = node_fs_1.default.readFileSync(filePath, 'utf8');
+        for (const line of content.split('\n')) {
+            const stripped = line.trim();
+            if (stripped.startsWith('# ')) {
+                return stripped.slice(2).trim() || node_path_1.default.basename(filePath).replace(/\.md$/, '').replace(/-/g, ' ').replace(/\b\w/g, (c) => c.toUpperCase());
+            }
+        }
+    }
+    catch {
+        // fall through
+    }
+    return node_path_1.default.basename(filePath).replace(/\.md$/, '').replace(/-/g, ' ').replace(/\b\w/g, (c) => c.toUpperCase());
+}
+function iterMemoryFiles(memoryDir) {
+    if (!node_fs_1.default.existsSync(memoryDir))
+        return [];
+    const entries = node_fs_1.default.readdirSync(memoryDir);
+    return entries
+        .filter((name) => name.endsWith('.md'))
+        .map((name) => node_path_1.default.join(memoryDir, name))
+        .filter((p) => node_fs_1.default.statSync(p).isFile())
+        .sort((a, b) => node_path_1.default.basename(a).toLowerCase().localeCompare(node_path_1.default.basename(b).toLowerCase()));
+}
+function renderSection(memoryFiles, sectionTitle, instructionLines) {
+    const lines = [START_MARKER, sectionTitle.trim(), ''];
+    const cleaned = instructionLines.filter((line) => line && line.trim());
+    for (const line of cleaned) {
+        lines.push(line.trim());
+    }
+    if (cleaned.length)
+        lines.push('');
+    if (memoryFiles.length) {
+        const entries = memoryFiles
+            .map((p) => ({ title: titleFromMemoryFile(p), resolved: node_path_1.default.resolve(p) }))
+            .sort((a, b) => a.title.toLowerCase().localeCompare(b.title.toLowerCase()) || a.resolved.localeCompare(b.resolved));
+        for (const { title, resolved } of entries) {
+            lines.push(`- [${title}](file://${resolved})`);
+        }
+    }
+    else {
+        lines.push('- No memory files are currently indexed.');
+    }
+    lines.push(END_MARKER);
+    return lines.join('\n');
+}
+function removeExistingSection(content) {
+    const pattern = new RegExp(`\n*${escapeRegex(START_MARKER)}[\\s\\S]*?${escapeRegex(END_MARKER)}\n*`, 'g');
+    return content.replace(pattern, '\n\n').trimEnd();
+}
+function escapeRegex(str) {
+    return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+function syncAgentsFile(agentsFile, sectionText) {
+    const dir = node_path_1.default.dirname(agentsFile);
+    node_fs_1.default.mkdirSync(dir, { recursive: true });
+    let original = '';
+    try {
+        original = node_fs_1.default.readFileSync(agentsFile, 'utf8');
+    }
+    catch {
+        // file doesn't exist
+    }
+    const base = removeExistingSection(original);
+    const updated = base ? `${base}\n\n${sectionText}\n` : `${sectionText}\n`;
+    node_fs_1.default.writeFileSync(agentsFile, updated, 'utf8');
+}
+function syncMemoryIndexHandler(args, context) {
+    try {
+        const homeDir = process.env.HOME || '';
+        let agentsFile = node_path_1.default.join(homeDir, '.codex', 'AGENTS.md');
+        let memoryDir = node_path_1.default.join(homeDir, '.codex', 'memory');
+        let sectionTitle = DEFAULT_SECTION_TITLE;
+        let instructionLines = [...DEFAULT_INSTRUCTIONS];
+        for (let i = 0; i < args.length; i++) {
+            if (args[i] === '--agents-file' && i + 1 < args.length)
+                agentsFile = args[++i];
+            else if (args[i] === '--memory-dir' && i + 1 < args.length)
+                memoryDir = args[++i];
+            else if (args[i] === '--section-title' && i + 1 < args.length)
+                sectionTitle = args[++i];
+            else if (args[i] === '--instruction-line' && i + 1 < args.length)
+                instructionLines.push(args[++i]);
+        }
+        const memoryFiles = iterMemoryFiles(memoryDir);
+        const sectionText = renderSection(memoryFiles, sectionTitle, instructionLines);
+        syncAgentsFile(agentsFile, sectionText);
+        context.stdout?.write(`SYNCED_AGENTS_FILE=${node_path_1.default.resolve(agentsFile)}\n`);
+        context.stdout?.write(`MEMORY_FILES_INDEXED=${memoryFiles.length}\n`);
+        return Promise.resolve(0);
+    }
+    catch (err) {
+        const stderr = context.stderr || process.stderr;
+        stderr.write(`Error: ${err.message}\n`);
+        return Promise.resolve(1);
+    }
+}

package/dist/lib/tools/validate-openai-agent-config.d.ts

@@ -0,0 +1,2 @@
+import type { ToolContext } from '../types';
+export declare function validateOpenaiAgentConfigHandler(args: string[], context: ToolContext): Promise<number>;

package/dist/lib/tools/validate-openai-agent-config.js

@@ -0,0 +1,190 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateOpenaiAgentConfigHandler = validateOpenaiAgentConfigHandler;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const js_yaml_1 = __importDefault(require("js-yaml"));
+const TOP_LEVEL_ALLOWED_KEYS = new Set(['interface', 'dependencies', 'policy']);
+const INTERFACE_REQUIRED_KEYS = new Set(['display_name', 'short_description', 'default_prompt']);
+const INTERFACE_ALLOWED_KEYS = new Set([
+    'display_name', 'short_description', 'default_prompt',
+    'icon_small', 'icon_large', 'brand_color',
+]);
+const HEX_COLOR_PATTERN = /^#[0-9A-Fa-f]{6}$/;
+function repoRoot(context) {
+    if (context?.sourceRoot)
+        return context.sourceRoot;
+    // __dirname is dist/lib/tools/; need to go up 3 levels to project root
+    const fromDirname = node_path_1.default.resolve(__dirname, '..', '..', '..');
+    if (node_fs_1.default.existsSync(node_path_1.default.join(fromDirname, 'package.json')))
+        return fromDirname;
+    return node_path_1.default.resolve(__dirname, '..', '..', '..');
+}
+function iterSkillDirs(root) {
+    return node_fs_1.default.readdirSync(root)
+        .filter((name) => {
+        const full = node_path_1.default.join(root, name);
+        return node_fs_1.default.statSync(full).isDirectory() && node_fs_1.default.existsSync(node_path_1.default.join(full, 'SKILL.md'));
+    })
+        .map((name) => node_path_1.default.join(root, name))
+        .sort();
+}
+function extractFrontmatter(content) {
+    const lines = content.split('\n');
+    if (!lines.length || lines[0].trim() !== '---') {
+        throw new Error("SKILL.md must start with YAML frontmatter delimiter '---'.");
+    }
+    for (let i = 1; i < lines.length; i++) {
+        if (lines[i].trim() === '---') {
+            const raw = lines.slice(1, i).join('\n');
+            const parsed = js_yaml_1.default.load(raw);
+            if (typeof parsed !== 'object' || parsed === null) {
+                throw new Error('SKILL.md frontmatter must be a YAML mapping.');
+            }
+            return parsed;
+        }
+    }
+    throw new Error("SKILL.md frontmatter is missing the closing '---' delimiter.");
+}
+function requireNonEmptyString(container, key, context, errors) {
+    const value = container[key];
+    if (typeof value !== 'string' || !value.trim()) {
+        errors.push(`${context}: '${key}' must be a non-empty string.`);
+    }
+}
+function validateDependencies(dependencies, context, errors) {
+    if (typeof dependencies !== 'object' || dependencies === null) {
+        errors.push(`${context}: 'dependencies' must be a mapping.`);
+        return;
+    }
+    const tools = dependencies['tools'];
+    if (tools === undefined)
+        return;
+    if (!Array.isArray(tools)) {
+        errors.push(`${context}: 'dependencies.tools' must be a list.`);
+        return;
+    }
+    for (let i = 0; i < tools.length; i++) {
+        const itemContext = `${context}: dependencies.tools[${i}]`;
+        const item = tools[i];
+        if (typeof item !== 'object' || item === null) {
+            errors.push(`${itemContext} must be a mapping.`);
+            continue;
+        }
+        requireNonEmptyString(item, 'type', itemContext, errors);
+        requireNonEmptyString(item, 'value', itemContext, errors);
+        if (typeof item['type'] === 'string' && item['type'] !== 'mcp') {
+            errors.push(`${itemContext}: unsupported tool type '${item['type']}', only 'mcp' is allowed.`);
+        }
+        for (const optionalKey of ['description', 'transport', 'url']) {
+            const optionalValue = item[optionalKey];
+            if (optionalValue !== undefined && (typeof optionalValue !== 'string' || !optionalValue.trim())) {
+                errors.push(`${itemContext}: '${optionalKey}' must be a non-empty string when provided.`);
+            }
+        }
+    }
+}
+function validatePolicy(policy, context, errors) {
+    if (typeof policy !== 'object' || policy === null) {
+        errors.push(`${context}: 'policy' must be a mapping.`);
+        return;
+    }
+    const allowImplicit = policy['allow_implicit_invocation'];
+    if (allowImplicit !== undefined && typeof allowImplicit !== 'boolean') {
+        errors.push(`${context}: 'policy.allow_implicit_invocation' must be a boolean when provided.`);
+    }
+}
+function validateSkill(skillDir) {
+    const errors = [];
+    const skillMd = node_path_1.default.join(skillDir, 'SKILL.md');
+    const openaiYaml = node_path_1.default.join(skillDir, 'agents', 'openai.yaml');
+    let skillFrontmatter;
+    try {
+        skillFrontmatter = extractFrontmatter(node_fs_1.default.readFileSync(skillMd, 'utf8'));
+    }
+    catch (exc) {
+        return [`${skillMd}: unable to read skill name for validation (${exc.message}).`];
+    }
+    const skillName = skillFrontmatter['name'];
+    if (typeof skillName !== 'string' || !skillName.trim()) {
+        return [`${skillMd}: frontmatter 'name' must be a non-empty string.`];
+    }
+    if (!node_fs_1.default.existsSync(openaiYaml)) {
+        return [`${openaiYaml}: file is required for every skill.`];
+    }
+    let parsed;
+    try {
+        parsed = js_yaml_1.default.load(node_fs_1.default.readFileSync(openaiYaml, 'utf8'));
+    }
+    catch (exc) {
+        return [`${openaiYaml}: invalid YAML (${exc.message}).`];
+    }
+    if (typeof parsed !== 'object' || parsed === null) {
+        return [`${openaiYaml}: top-level structure must be a YAML mapping.`];
+    }
+    const topLevelKeys = new Set(Object.keys(parsed));
+    const unsupportedTopKeys = [...topLevelKeys].filter((k) => !TOP_LEVEL_ALLOWED_KEYS.has(k)).sort();
+    if (unsupportedTopKeys.length) {
+        errors.push(`${openaiYaml}: unsupported top-level keys: ${unsupportedTopKeys.join(', ')}.`);
+    }
+    const iface = parsed['interface'];
+    if (typeof iface !== 'object' || iface === null) {
+        errors.push(`${openaiYaml}: 'interface' must be a mapping.`);
+        return errors;
+    }
+    const missingInterfaceKeys = [...INTERFACE_REQUIRED_KEYS].filter((k) => !(k in iface)).sort();
+    if (missingInterfaceKeys.length) {
+        errors.push(`${openaiYaml}: missing required interface keys: ${missingInterfaceKeys.join(', ')}.`);
+    }
+    const unsupportedInterfaceKeys = Object.keys(iface).filter((k) => !INTERFACE_ALLOWED_KEYS.has(k)).sort();
+    if (unsupportedInterfaceKeys.length) {
+        errors.push(`${openaiYaml}: unsupported interface keys: ${unsupportedInterfaceKeys.join(', ')}.`);
+    }
+    for (const requiredKey of [...INTERFACE_REQUIRED_KEYS].sort()) {
+        requireNonEmptyString(iface, requiredKey, `${openaiYaml}`, errors);
+    }
+    const defaultPrompt = iface['default_prompt'];
+    const expectedSkillRef = `$${skillName.trim()}`;
+    if (typeof defaultPrompt === 'string' && !defaultPrompt.includes(expectedSkillRef)) {
+        errors.push(`${openaiYaml}: interface.default_prompt must reference '${expectedSkillRef}'.`);
+    }
+    const brandColor = iface['brand_color'];
+    if (brandColor !== undefined) {
+        if (typeof brandColor !== 'string' || !HEX_COLOR_PATTERN.test(brandColor)) {
+            errors.push(`${openaiYaml}: interface.brand_color must be a hex color like '#1A2B3C'.`);
+        }
+    }
+    const dependencies = parsed['dependencies'];
+    if (dependencies !== undefined) {
+        validateDependencies(dependencies, `${openaiYaml}`, errors);
+    }
+    const policy = parsed['policy'];
+    if (policy !== undefined) {
+        validatePolicy(policy, `${openaiYaml}`, errors);
+    }
+    return errors;
+}
+function validateOpenaiAgentConfigHandler(args, context) {
+    const root = repoRoot(context);
+    const skillDirs = iterSkillDirs(root);
+    if (!skillDirs.length) {
+        context.stdout?.write('No top-level skill directories found.\n');
+        return Promise.resolve(1);
+    }
+    const allErrors = [];
+    for (const dir of skillDirs) {
+        allErrors.push(...validateSkill(dir));
+    }
+    if (allErrors.length) {
+        context.stdout?.write('agents/openai.yaml validation failed:\n');
+        for (const error of allErrors) {
+            context.stdout?.write(`- ${error}\n`);
+        }
+        return Promise.resolve(1);
+    }
+    context.stdout?.write(`agents/openai.yaml validation passed for ${skillDirs.length} skills.\n`);
+    return Promise.resolve(0);
+}

package/dist/lib/tools/validate-skill-frontmatter.d.ts

@@ -0,0 +1,2 @@
+import type { ToolContext } from '../types';
+export declare function validateSkillFrontmatterHandler(args: string[], context: ToolContext): Promise<number>;

package/dist/lib/tools/validate-skill-frontmatter.js

@@ -0,0 +1,118 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateSkillFrontmatterHandler = validateSkillFrontmatterHandler;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const NAME_PATTERN = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+const REQUIRED_KEYS = new Set(['name', 'description']);
+const MAX_DESCRIPTION_LENGTH = 1024;
+function repoRoot(context) {
+    if (context?.sourceRoot)
+        return context.sourceRoot;
+    // __dirname is dist/lib/tools/; need to go up 3 levels to project root
+    const fromDirname = node_path_1.default.resolve(__dirname, '..', '..', '..');
+    if (node_fs_1.default.existsSync(node_path_1.default.join(fromDirname, 'package.json')))
+        return fromDirname;
+    return node_path_1.default.resolve(__dirname, '..', '..', '..');
+}
+function iterSkillDirs(root) {
+    return node_fs_1.default.readdirSync(root)
+        .filter((name) => {
+        const full = node_path_1.default.join(root, name);
+        return node_fs_1.default.statSync(full).isDirectory() && node_fs_1.default.existsSync(node_path_1.default.join(full, 'SKILL.md'));
+    })
+        .map((name) => node_path_1.default.join(root, name))
+        .sort();
+}
+function extractFrontmatter(content) {
+    const lines = content.split('\n');
+    if (!lines.length || lines[0].trim() !== '---') {
+        throw new Error("SKILL.md must start with YAML frontmatter delimiter '---'.");
+    }
+    for (let i = 1; i < lines.length; i++) {
+        if (lines[i].trim() === '---') {
+            return lines.slice(1, i).join('\n');
+        }
+    }
+    throw new Error("SKILL.md frontmatter is missing the closing '---' delimiter.");
+}
+function validateSkill(skillDir) {
+    const errors = [];
+    const skillMd = node_path_1.default.join(skillDir, 'SKILL.md');
+    let content;
+    try {
+        content = node_fs_1.default.readFileSync(skillMd, 'utf8');
+    }
+    catch (exc) {
+        return [`${skillMd}: cannot read file (${exc.message}).`];
+    }
+    let frontmatterText;
+    try {
+        frontmatterText = extractFrontmatter(content);
+    }
+    catch (exc) {
+        return [`${skillMd}: ${exc.message}`];
+    }
+    // Simple YAML-like parsing for frontmatter (handles the common cases)
+    let frontmatter = {};
+    for (const line of frontmatterText.split('\n')) {
+        const match = line.match(/^(\w+):\s*(.*)$/);
+        if (match) {
+            frontmatter[match[1]] = match[2].trim();
+        }
+    }
+    const keys = new Set(Object.keys(frontmatter));
+    const missing = [...REQUIRED_KEYS].filter((k) => !keys.has(k));
+    const extra = [...keys].filter((k) => !REQUIRED_KEYS.has(k));
+    if (missing.length) {
+        errors.push(`${skillMd}: missing required frontmatter keys: ${missing.join(', ')}.`);
+    }
+    if (extra.length) {
+        errors.push(`${skillMd}: unsupported frontmatter keys: ${extra.join(', ')}.`);
+    }
+    const name = frontmatter['name'];
+    if (typeof name !== 'string' || !name.trim()) {
+        errors.push(`${skillMd}: 'name' must be a non-empty string.`);
+    }
+    else {
+        const normalizedName = name.trim();
+        if (!NAME_PATTERN.test(normalizedName)) {
+            errors.push(`${skillMd}: 'name' must be kebab-case (lowercase letters, digits, and hyphens).`);
+        }
+        if (normalizedName !== node_path_1.default.basename(skillDir)) {
+            errors.push(`${skillMd}: frontmatter name '${normalizedName}' must match folder name '${node_path_1.default.basename(skillDir)}'.`);
+        }
+    }
+    const description = frontmatter['description'];
+    if (typeof description !== 'string' || !description.trim()) {
+        errors.push(`${skillMd}: 'description' must be a non-empty string.`);
+    }
+    else if (description.length > MAX_DESCRIPTION_LENGTH) {
+        errors.push(`${skillMd}: invalid description: exceeds maximum length of ${MAX_DESCRIPTION_LENGTH} characters`);
+    }
+    return errors;
+}
+function validateSkillFrontmatterHandler(args, context) {
+    const root = repoRoot(context);
+    const skillDirs = iterSkillDirs(root);
+    if (!skillDirs.length) {
+        context.stdout?.write('No top-level skill directories found.\n');
+        return Promise.resolve(1);
+    }
+    const allErrors = [];
+    for (const dir of skillDirs) {
+        allErrors.push(...validateSkill(dir));
+    }
+    if (allErrors.length) {
+        context.stdout?.write('SKILL.md frontmatter validation failed:\n');
+        for (const error of allErrors) {
+            context.stdout?.write(`- ${error}\n`);
+        }
+        return Promise.resolve(1);
+    }
+    context.stdout?.write(`SKILL.md frontmatter validation passed for ${skillDirs.length} skills.\n`);
+    return Promise.resolve(0);
+}

package/dist/lib/types.d.ts

@@ -0,0 +1,82 @@
+export interface ToolHelp {
+    purpose: string;
+    useWhen: string[];
+    insteadOf?: string[];
+    examples?: ToolExample[];
+}
+export interface ToolExample {
+    command: string;
+    result: string;
+}
+export type RunnerKind = 'node' | 'python3' | 'swift';
+export interface ToolDefinition {
+    name: string;
+    category: string;
+    skill?: string;
+    script?: string;
+    runner?: RunnerKind;
+    description: string;
+    aliases?: string[];
+    help?: ToolHelp;
+    /** Direct function reference for the tool handler (replaces spawn-based execution). */
+    handler?: (args: string[], context: ToolContext) => Promise<number>;
+    canonicalName?: string;
+}
+export interface ToolContext {
+    sourceRoot?: string;
+    stdout?: NodeJS.WriteStream;
+    stderr?: NodeJS.WriteStream;
+    env?: NodeJS.ProcessEnv;
+    spawnCommand?: Function;
+    cwd?: string;
+    stdio?: any;
+}
+export type InstallMode = 'codex' | 'openclaw' | 'trae' | 'agents' | 'claude-code';
+export interface InstallTarget {
+    id: InstallMode;
+    label: string;
+    description?: string;
+    root?: string;
+}
+export interface InstallResult {
+    skillNames: string[];
+    linkMode: 'symlink' | 'copy';
+    targets: {
+        label: string;
+        root: string;
+    }[];
+}
+export interface ManifestData {
+    version: string;
+    installedAt: string;
+    linkMode: string;
+    skills: string[];
+    historicalSkills: string[];
+}
+export interface SyncResult {
+    previousSkillNames: string[];
+}
+export interface ParsedArguments {
+    command: 'install' | 'uninstall' | 'tool' | 'tools-help';
+    modes: InstallMode[];
+    showHelp: boolean;
+    showToolsHelp: boolean;
+    toolkitHome: string | null;
+    toolName: string | null;
+    toolArgs: string[];
+    linkMode: 'copy' | 'symlink' | null;
+    assumeYes: boolean;
+    explicitInstallCommand: boolean;
+    helpTopic: string;
+}
+export interface CliContext {
+    sourceRoot?: string;
+    stdout?: NodeJS.WriteStream;
+    stderr?: NodeJS.WriteStream;
+    stdin?: NodeJS.ReadStream;
+    env?: NodeJS.ProcessEnv;
+    execCommand?: Function;
+    confirmUpdate?: Function;
+    runTool?: Function;
+    spawnCommand?: Function;
+}

package/dist/lib/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/lib/updater.d.ts

@@ -0,0 +1,34 @@
+interface ExecResult {
+    stdout: string;
+    stderr: string;
+}
+interface UpdateCheckResult {
+    checked: boolean;
+    updated: boolean;
+    latestVersion?: string;
+    error?: Error;
+}
+export declare function compareVersions(left: string, right: string): number;
+export declare function execCommand(command: string, args: string[], { env, stdout, stderr }?: {
+    env?: NodeJS.ProcessEnv;
+    stdout?: NodeJS.WriteStream;
+    stderr?: NodeJS.WriteStream;
+}): Promise<ExecResult>;
+declare function defaultConfirmUpdate({ stdin, stdout, currentVersion, latestVersion, packageName }: {
+    stdin: NodeJS.ReadStream;
+    stdout: NodeJS.WriteStream;
+    currentVersion: string;
+    latestVersion: string;
+    packageName: string;
+}): Promise<boolean>;
+export declare function checkForPackageUpdate({ packageName, currentVersion, env, stdin, stdout, stderr, exec, confirmUpdate }: {
+    packageName: string;
+    currentVersion: string;
+    env?: NodeJS.ProcessEnv;
+    stdin?: NodeJS.ReadStream;
+    stdout?: NodeJS.WriteStream;
+    stderr?: NodeJS.WriteStream;
+    exec?: typeof execCommand;
+    confirmUpdate?: typeof defaultConfirmUpdate;
+}): Promise<UpdateCheckResult>;
+export {};

package/dist/lib/updater.js

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compareVersions = compareVersions;
+exports.execCommand = execCommand;
+exports.checkForPackageUpdate = checkForPackageUpdate;
+const node_child_process_1 = require("node:child_process");
+const promises_1 = require("node:readline/promises");
+function normalizeVersion(version) {
+    return String(version || '')
+        .trim()
+        .replace(/^v/i, '');
+}
+function parseVersion(version) {
+    const normalized = normalizeVersion(version);
+    const [core, prerelease = ''] = normalized.split('-', 2);
+    const parts = core.split('.').map((part) => Number.parseInt(part, 10) || 0);
+    return { parts, prerelease };
+}
+function compareVersions(left, right) {
+    const leftVersion = parseVersion(left);
+    const rightVersion = parseVersion(right);
+    const leftParts = leftVersion.parts;
+    const rightParts = rightVersion.parts;
+    const length = Math.max(leftParts.length, rightParts.length);
+    for (let index = 0; index < length; index += 1) {
+        const delta = (leftParts[index] || 0) - (rightParts[index] || 0);
+        if (delta !== 0)
+            return delta;
+    }
+    if (leftVersion.prerelease && !rightVersion.prerelease)
+        return -1;
+    if (!leftVersion.prerelease && rightVersion.prerelease)
+        return 1;
+    if (leftVersion.prerelease !== rightVersion.prerelease) {
+        return leftVersion.prerelease.localeCompare(rightVersion.prerelease);
+    }
+    return 0;
+}
+function shouldSkipUpdateCheck({ env = process.env, stdin = process.stdin, stdout = process.stdout }) {
+    return env.APOLLO_TOOLKIT_SKIP_UPDATE_CHECK === '1' || !stdin.isTTY || !stdout.isTTY;
+}
+function execCommand(command, args, { env = process.env, stdout, stderr } = {}) {
+    return new Promise((resolve, reject) => {
+        const child = (0, node_child_process_1.spawn)(command, args, {
+            env,
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+        let capturedStdout = '';
+        let capturedStderr = '';
+        child.stdout.on('data', (chunk) => {
+            capturedStdout += chunk.toString('utf8');
+            if (stdout)
+                stdout.write(chunk);
+        });
+        child.stderr.on('data', (chunk) => {
+            capturedStderr += chunk.toString('utf8');
+            if (stderr)
+                stderr.write(chunk);
+        });
+        child.on('error', reject);
+        child.on('close', (code) => {
+            if (code !== 0) {
+                reject(new Error(capturedStderr.trim() || `${command} exited with code ${code}`));
+                return;
+            }
+            resolve({ stdout: capturedStdout, stderr: capturedStderr });
+        });
+    });
+}
+async function defaultConfirmUpdate({ stdin, stdout, currentVersion, latestVersion, packageName }) {
+    const rl = (0, promises_1.createInterface)({ input: stdin, output: stdout });
+    try {
+        const answer = await rl.question(`A newer ${packageName} release is available (${currentVersion} -> ${latestVersion}). Update now? [Y/n] `);
+        const normalized = answer.trim().toLowerCase();
+        return normalized === '' || normalized === 'y';
+    }
+    finally {
+        rl.close();
+    }
+}
+async function getLatestPublishedVersion({ packageName, env = process.env, exec = execCommand }) {
+    const result = await exec('npm', ['view', packageName, 'version', '--json'], { env });
+    const parsed = JSON.parse(result.stdout.trim());
+    if (Array.isArray(parsed)) {
+        return String(parsed[parsed.length - 1] || '').trim();
+    }
+    return String(parsed || '').trim();
+}
+async function checkForPackageUpdate({ packageName, currentVersion, env = process.env, stdin = process.stdin, stdout = process.stdout, stderr = process.stderr, exec = execCommand, confirmUpdate = defaultConfirmUpdate }) {
+    if (shouldSkipUpdateCheck({ env, stdin, stdout })) {
+        return { checked: false, updated: false };
+    }
+    try {
+        const latestVersion = await getLatestPublishedVersion({ packageName, env, exec });
+        if (!latestVersion || compareVersions(latestVersion, currentVersion) <= 0) {
+            return { checked: true, updated: false, latestVersion };
+        }
+        const approved = await confirmUpdate({ stdin, stdout, currentVersion, latestVersion, packageName });
+        if (!approved) {
+            stdout.write(`Continuing with ${packageName} ${currentVersion}.\n`);
+            return { checked: true, updated: false, latestVersion };
+        }
+        stdout.write(`Updating ${packageName} to ${latestVersion}...\n`);
+        await exec('npm', ['install', '-g', `${packageName}@latest`], { env, stdout, stderr });
+        stdout.write(`Update complete. Continuing with ${packageName} ${latestVersion}.\n`);
+        return { checked: true, updated: true, latestVersion };
+    }
+    catch (error) {
+        stderr.write(`Warning: unable to check or install package updates: ${error.message}\n`);
+        return { checked: false, updated: false, error: error };
+    }
+}

package/dist/lib/utils/format.d.ts

@@ -0,0 +1,2 @@
+import type { ToolExample } from '../types';
+export declare function formatExamples(examples?: ToolExample[]): string;

package/dist/lib/utils/format.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatExamples = formatExamples;
+function formatExamples(examples = []) {
+    return examples.map(({ command, result }) => (`  ${command}\n    Result: ${result}`)).join('\n');
+}