edsger 0.35.2 → 0.36.0

package/dist/api/app-store-iap.d.ts

@@ -0,0 +1,60 @@
+export interface IAPLocalization {
+    name: string;
+    description?: string;
+}
+export interface IAPProduct {
+    id: string;
+    apple_id?: string;
+    product_id: string;
+    type: 'consumable' | 'non_consumable' | 'non_renewing_subscription' | 'auto_renewable_subscription';
+    family_shareable: boolean;
+    review_note?: string;
+    status: string;
+    subscription_group?: string;
+    subscription_group_apple_id?: string;
+    duration?: string;
+    base_territory: string;
+    base_price?: string;
+    localizations: Record<string, IAPLocalization>;
+}
+/**
+ * List all IAP products for a config
+ */
+export declare function listIAPProducts(configId: string, verbose?: boolean): Promise<IAPProduct[]>;
+/**
+ * Get a single IAP product
+ */
+export declare function getIAPProduct(configId: string, iapId: string, verbose?: boolean): Promise<IAPProduct | null>;
+/**
+ * Create a new IAP product (local draft)
+ */
+export declare function createIAPProduct(params: {
+    config_id: string;
+    product_id: string;
+    type: IAPProduct['type'];
+    family_shareable?: boolean;
+    review_note?: string;
+    subscription_group?: string;
+    duration?: string;
+    base_territory?: string;
+    base_price?: string;
+    localizations?: Record<string, IAPLocalization>;
+}, verbose?: boolean): Promise<IAPProduct | null>;
+/**
+ * Update an existing IAP product (local)
+ */
+export declare function updateIAPProduct(configId: string, iapId: string, updates: {
+    review_note?: string;
+    family_shareable?: boolean;
+    base_territory?: string;
+    base_price?: string;
+    localizations?: Record<string, IAPLocalization>;
+}, verbose?: boolean): Promise<IAPProduct | null>;
+/**
+ * Delete an IAP product (local)
+ */
+export declare function deleteIAPProduct(configId: string, iapId: string, verbose?: boolean): Promise<boolean>;
+/**
+ * Save the full IAP array (batch replacement)
+ */
+export declare function saveIAPProducts(configId: string, iaps: IAPProduct[], verbose?: boolean): Promise<IAPProduct[]>;

package/dist/api/app-store-iap.js

@@ -0,0 +1,145 @@
+import { logError, logInfo } from '../utils/logger.js';
+import { callMcpEndpoint } from './mcp-client.js';
+// ========== MCP CRUD (local DB) ==========
+/**
+ * List all IAP products for a config
+ */
+export async function listIAPProducts(configId, verbose) {
+    if (verbose) {
+        logInfo(`Fetching IAPs for config: ${configId}`);
+    }
+    try {
+        const result = (await callMcpEndpoint('app_store/iap/list', {
+            config_id: configId,
+        }));
+        const text = result.content?.[0]?.text || '[]';
+        try {
+            return JSON.parse(text);
+        }
+        catch {
+            return [];
+        }
+    }
+    catch (error) {
+        if (verbose) {
+            logError(`Failed to fetch IAPs: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        return [];
+    }
+}
+/**
+ * Get a single IAP product
+ */
+export async function getIAPProduct(configId, iapId, verbose) {
+    try {
+        const result = (await callMcpEndpoint('app_store/iap/get', {
+            config_id: configId,
+            iap_id: iapId,
+        }));
+        const text = result.content?.[0]?.text || 'null';
+        try {
+            return JSON.parse(text);
+        }
+        catch {
+            return null;
+        }
+    }
+    catch (error) {
+        if (verbose) {
+            logError(`Failed to fetch IAP: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        return null;
+    }
+}
+/**
+ * Create a new IAP product (local draft)
+ */
+export async function createIAPProduct(params, verbose) {
+    if (verbose) {
+        logInfo(`Creating IAP: ${params.product_id} (${params.type})`);
+    }
+    try {
+        const result = (await callMcpEndpoint('app_store/iap/create', params));
+        const text = result.content?.[0]?.text || 'null';
+        try {
+            return JSON.parse(text);
+        }
+        catch {
+            return null;
+        }
+    }
+    catch (error) {
+        logError(`Failed to create IAP: ${error instanceof Error ? error.message : String(error)}`);
+        return null;
+    }
+}
+/**
+ * Update an existing IAP product (local)
+ */
+export async function updateIAPProduct(configId, iapId, updates, verbose) {
+    if (verbose) {
+        logInfo(`Updating IAP: ${iapId}`);
+    }
+    try {
+        const result = (await callMcpEndpoint('app_store/iap/update', {
+            config_id: configId,
+            iap_id: iapId,
+            ...updates,
+        }));
+        const text = result.content?.[0]?.text || 'null';
+        try {
+            return JSON.parse(text);
+        }
+        catch {
+            return null;
+        }
+    }
+    catch (error) {
+        logError(`Failed to update IAP: ${error instanceof Error ? error.message : String(error)}`);
+        return null;
+    }
+}
+/**
+ * Delete an IAP product (local)
+ */
+export async function deleteIAPProduct(configId, iapId, verbose) {
+    if (verbose) {
+        logInfo(`Deleting IAP: ${iapId}`);
+    }
+    try {
+        await callMcpEndpoint('app_store/iap/delete', {
+            config_id: configId,
+            iap_id: iapId,
+        });
+        return true;
+    }
+    catch (error) {
+        logError(`Failed to delete IAP: ${error instanceof Error ? error.message : String(error)}`);
+        return false;
+    }
+}
+/**
+ * Save the full IAP array (batch replacement)
+ */
+export async function saveIAPProducts(configId, iaps, verbose) {
+    if (verbose) {
+        logInfo(`Saving ${iaps.length} IAP(s) for config: ${configId}`);
+    }
+    try {
+        const result = (await callMcpEndpoint('app_store/iap/save', {
+            config_id: configId,
+            in_app_purchases: iaps,
+        }));
+        const text = result.content?.[0]?.text || '[]';
+        try {
+            return JSON.parse(text);
+        }
+        catch {
+            return [];
+        }
+    }
+    catch (error) {
+        logError(`Failed to save IAPs: ${error instanceof Error ? error.message : String(error)}`);
+        return [];
+    }
+}

package/dist/api/app-store.d.ts

@@ -1,3 +1,10 @@
+export interface BuildConfig {
+    project_path?: string;
+    scheme?: string;
+    configuration?: string;
+    team_id?: string;
+    export_method?: string;
+}
 export interface AppStoreConfig {
     id: string;
     product_id: string;
@@ -6,6 +13,7 @@ export interface AppStoreConfig {
     app_identifier: string | null;
     listings: Record<string, AppStoreListing>;
     screenshots: Record<string, AppStoreScreenshot[]>;
+    build_config: BuildConfig;
     current_version: string | null;
     submission_status: string;
     submitted_at: string | null;
@@ -79,3 +87,7 @@ export declare function updateAppStoreStatus(configId: string, updates: {
  * Returns the locale string (e.g. "en-US") or null if unavailable.
  */
 export declare function getAppStorePrimaryLocale(productId: string, verbose?: boolean): Promise<string | null>;
+/**
+ * Update build configuration for an app store config via MCP
+ */
+export declare function updateBuildConfig(configId: string, buildConfig: BuildConfig, verbose?: boolean): Promise<AppStoreConfig | null>;

package/dist/api/app-store.js

@@ -179,3 +179,28 @@ export async function getAppStorePrimaryLocale(productId, verbose) {
         return null;
     }
 }
+/**
+ * Update build configuration for an app store config via MCP
+ */
+export async function updateBuildConfig(configId, buildConfig, verbose) {
+    if (verbose) {
+        logInfo(`Saving build config for: ${configId}`);
+    }
+    try {
+        const result = (await callMcpEndpoint('app_store/configs/save_build_config', {
+            config_id: configId,
+            build_config: buildConfig,
+        }));
+        const text = result.content?.[0]?.text || 'null';
+        try {
+            return JSON.parse(text);
+        }
+        catch {
+            return null;
+        }
+    }
+    catch (error) {
+        logError(`Failed to save build config: ${error instanceof Error ? error.message : String(error)}`);
+        return null;
+    }
+}

package/dist/commands/build/__tests__/build.test.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Unit tests for the build command's pure/utility functions.
+ * Tests project discovery, scheme parsing, plist generation, and API key management.
+ */
+export {};

package/dist/commands/build/__tests__/build.test.js

@@ -0,0 +1,206 @@
+/**
+ * Unit tests for the build command's pure/utility functions.
+ * Tests project discovery, scheme parsing, plist generation, and API key management.
+ */
+import assert from 'node:assert';
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync, } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { afterEach, beforeEach, describe, it } from 'node:test';
+import { cleanupApiKeyFile, discoverSchemes, findXcodeProjects, generateExportOptionsPlist, writeApiKeyFile, } from '../index.js';
+// ── Helpers ────────────────────────────────────────────────────────
+function createTmpDir() {
+    const dir = join(tmpdir(), `edsger-build-test-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+    mkdirSync(dir, { recursive: true });
+    return dir;
+}
+// ── findXcodeProjects ──────────────────────────────────────────────
+describe('findXcodeProjects', () => {
+    let tmpDir;
+    beforeEach(() => {
+        tmpDir = createTmpDir();
+    });
+    afterEach(() => {
+        rmSync(tmpDir, { recursive: true, force: true });
+    });
+    it('returns empty array for directory with no Xcode projects', () => {
+        mkdirSync(join(tmpDir, 'src'), { recursive: true });
+        writeFileSync(join(tmpDir, 'src', 'main.swift'), '');
+        const results = findXcodeProjects(tmpDir);
+        assert.deepStrictEqual(results, []);
+    });
+    it('finds a single .xcodeproj', () => {
+        mkdirSync(join(tmpDir, 'MyApp.xcodeproj'), { recursive: true });
+        const results = findXcodeProjects(tmpDir);
+        assert.strictEqual(results.length, 1);
+        assert.strictEqual(results[0].path, 'MyApp.xcodeproj');
+        assert.strictEqual(results[0].type, 'project');
+    });
+    it('finds a single .xcworkspace', () => {
+        mkdirSync(join(tmpDir, 'MyApp.xcworkspace'), { recursive: true });
+        const results = findXcodeProjects(tmpDir);
+        assert.strictEqual(results.length, 1);
+        assert.strictEqual(results[0].path, 'MyApp.xcworkspace');
+        assert.strictEqual(results[0].type, 'workspace');
+    });
+    it('sorts workspaces before projects', () => {
+        mkdirSync(join(tmpDir, 'MyApp.xcodeproj'), { recursive: true });
+        mkdirSync(join(tmpDir, 'MyApp.xcworkspace'), { recursive: true });
+        const results = findXcodeProjects(tmpDir);
+        assert.strictEqual(results.length, 2);
+        assert.strictEqual(results[0].type, 'workspace');
+        assert.strictEqual(results[1].type, 'project');
+    });
+    it('finds projects in subdirectories', () => {
+        mkdirSync(join(tmpDir, 'ios', 'MyApp.xcworkspace'), { recursive: true });
+        const results = findXcodeProjects(tmpDir);
+        assert.strictEqual(results.length, 1);
+        assert.strictEqual(results[0].path, join('ios', 'MyApp.xcworkspace'));
+    });
+    it('excludes Pods directory', () => {
+        mkdirSync(join(tmpDir, 'Pods', 'SomePod.xcodeproj'), { recursive: true });
+        mkdirSync(join(tmpDir, 'MyApp.xcodeproj'), { recursive: true });
+        const results = findXcodeProjects(tmpDir);
+        assert.strictEqual(results.length, 1);
+        assert.strictEqual(results[0].path, 'MyApp.xcodeproj');
+    });
+    it('excludes node_modules directory', () => {
+        mkdirSync(join(tmpDir, 'node_modules', 'react-native', 'React.xcodeproj'), {
+            recursive: true,
+        });
+        mkdirSync(join(tmpDir, 'ios', 'MyApp.xcodeproj'), { recursive: true });
+        const results = findXcodeProjects(tmpDir);
+        assert.strictEqual(results.length, 1);
+        assert.strictEqual(results[0].path, join('ios', 'MyApp.xcodeproj'));
+    });
+    it('excludes DerivedData directory', () => {
+        mkdirSync(join(tmpDir, 'DerivedData', 'Build.xcodeproj'), {
+            recursive: true,
+        });
+        const results = findXcodeProjects(tmpDir);
+        assert.strictEqual(results.length, 0);
+    });
+    it('excludes .build directory', () => {
+        mkdirSync(join(tmpDir, '.build', 'Something.xcodeproj'), {
+            recursive: true,
+        });
+        const results = findXcodeProjects(tmpDir);
+        assert.strictEqual(results.length, 0);
+    });
+    it('sorts shallower paths first among same type', () => {
+        mkdirSync(join(tmpDir, 'deep', 'nested', 'A.xcodeproj'), {
+            recursive: true,
+        });
+        mkdirSync(join(tmpDir, 'B.xcodeproj'), { recursive: true });
+        const results = findXcodeProjects(tmpDir);
+        assert.strictEqual(results[0].path, 'B.xcodeproj');
+    });
+    it('does not recurse deeper than 4 levels', () => {
+        mkdirSync(join(tmpDir, 'a', 'b', 'c', 'd', 'e', 'Deep.xcodeproj'), {
+            recursive: true,
+        });
+        const results = findXcodeProjects(tmpDir);
+        assert.strictEqual(results.length, 0);
+    });
+    it('finds projects at exactly depth 4', () => {
+        mkdirSync(join(tmpDir, 'a', 'b', 'c', 'd', 'Ok.xcodeproj'), {
+            recursive: true,
+        });
+        const results = findXcodeProjects(tmpDir);
+        assert.strictEqual(results.length, 1);
+    });
+});
+// ── generateExportOptionsPlist ─────────────────────────────────────
+describe('generateExportOptionsPlist', () => {
+    it('generates valid plist with app-store method', () => {
+        const plist = generateExportOptionsPlist('TEAM123', 'app-store');
+        assert.ok(plist.includes('<?xml version="1.0"'));
+        assert.ok(plist.includes('<string>app-store</string>'));
+        assert.ok(plist.includes('<string>TEAM123</string>'));
+        assert.ok(plist.includes('<key>uploadSymbols</key>'));
+        assert.ok(plist.includes('<true/>'));
+        assert.ok(plist.includes('<string>automatic</string>'));
+    });
+    it('generates plist with ad-hoc method', () => {
+        const plist = generateExportOptionsPlist('ABCD', 'ad-hoc');
+        assert.ok(plist.includes('<string>ad-hoc</string>'));
+        assert.ok(plist.includes('<string>ABCD</string>'));
+    });
+    it('generates plist with development method', () => {
+        const plist = generateExportOptionsPlist('XYZ', 'development');
+        assert.ok(plist.includes('<string>development</string>'));
+    });
+    it('includes all required keys', () => {
+        const plist = generateExportOptionsPlist('T', 'app-store');
+        assert.ok(plist.includes('<key>method</key>'));
+        assert.ok(plist.includes('<key>teamID</key>'));
+        assert.ok(plist.includes('<key>uploadSymbols</key>'));
+        assert.ok(plist.includes('<key>signingStyle</key>'));
+    });
+    it('escapes XML special characters in teamId', () => {
+        const plist = generateExportOptionsPlist('</string><key>evil</key><string>', 'app-store');
+        assert.ok(!plist.includes('<key>evil</key>'));
+        assert.ok(plist.includes('&lt;/string&gt;&lt;key&gt;evil&lt;/key&gt;&lt;string&gt;'));
+    });
+    it('escapes XML special characters in exportMethod', () => {
+        const plist = generateExportOptionsPlist('TEAM', 'a&b<c>');
+        assert.ok(plist.includes('a&amp;b&lt;c&gt;'));
+    });
+});
+// ── API key file management ────────────────────────────────────────
+describe('writeApiKeyFile', () => {
+    const testKeyId = `test-key-${Date.now()}`;
+    const testPrivateKey = '-----BEGIN PRIVATE KEY-----\ntest\n-----END PRIVATE KEY-----';
+    afterEach(() => {
+        cleanupApiKeyFile(testKeyId);
+    });
+    it('writes key file with correct content', () => {
+        const keyPath = writeApiKeyFile(testKeyId, testPrivateKey);
+        assert.ok(existsSync(keyPath));
+        assert.strictEqual(readFileSync(keyPath, 'utf-8'), testPrivateKey);
+    });
+    it('writes key file to ~/.edsger/keys/ directory', () => {
+        const keyPath = writeApiKeyFile(testKeyId, testPrivateKey);
+        assert.ok(keyPath.includes('.edsger'));
+        assert.ok(keyPath.includes('keys'));
+        assert.ok(keyPath.endsWith(`.p8`));
+    });
+    it('names file as AuthKey_<keyId>.p8', () => {
+        const keyPath = writeApiKeyFile(testKeyId, testPrivateKey);
+        assert.ok(keyPath.endsWith(`AuthKey_${testKeyId}.p8`));
+    });
+    it('rejects keyId with path traversal characters', () => {
+        assert.throws(() => writeApiKeyFile('../../etc/evil', 'key'), (err) => err.message.includes('Invalid API key ID'));
+    });
+    it('rejects keyId with slashes', () => {
+        assert.throws(() => writeApiKeyFile('key/id', 'key'), (err) => err.message.includes('Invalid API key ID'));
+    });
+});
+describe('cleanupApiKeyFile', () => {
+    it('removes existing key file', () => {
+        const testKeyId = `cleanup-test-${Date.now()}`;
+        const keyPath = writeApiKeyFile(testKeyId, 'test');
+        assert.ok(existsSync(keyPath));
+        cleanupApiKeyFile(testKeyId);
+        assert.ok(!existsSync(keyPath));
+    });
+    it('does not throw for non-existent key', () => {
+        assert.doesNotThrow(() => {
+            cleanupApiKeyFile('non-existent-key-id');
+        });
+    });
+});
+// ── discoverSchemes ────────────────────────────────────────────────
+// Note: These tests only run meaningfully on macOS with Xcode installed.
+// They verify the parsing logic by checking that the function doesn't crash
+// when given a non-existent project (returns empty array).
+describe('discoverSchemes', () => {
+    it('returns empty array for non-existent project', () => {
+        const schemes = discoverSchemes('/tmp', 'nonexistent.xcodeproj', 'project');
+        assert.deepStrictEqual(schemes, []);
+    });
+    it('returns empty array for non-existent workspace', () => {
+        const schemes = discoverSchemes('/tmp', 'nonexistent.xcworkspace', 'workspace');
+        assert.deepStrictEqual(schemes, []);
+    });
+});

package/dist/commands/build/__tests__/run-build.test.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Integration tests for the runBuild orchestration function.
+ * Uses dependency injection (BuildDeps) to mock external calls
+ * while testing the full decision-making pipeline.
+ */
+export {};