specrails-desktop 2.30.2 → 2.31.0

package/server/dist/profile-manager.js

@@ -59,9 +59,39 @@ exports.ProfileConflictError = ProfileConflictError;
 function profilesDir(projectPath) {
     return path_1.default.join(projectPath, '.specrails', 'profiles');
 }
-function profilePath(projectPath, name) {
+function legacyProfilePath(projectPath, name) {
     return path_1.default.join(profilesDir(projectPath), `${name}.json`);
 }
+/** Provider-scoped filenames allow e.g. Claude and Kimi to both own a logical
+ * `default` profile. The JSON body keeps the user-facing name unchanged. */
+function scopedProfilePath(projectPath, name, provider) {
+    return path_1.default.join(profilesDir(projectPath), `${provider}--${name}.json`);
+}
+function profileCandidates(projectPath, name, provider) {
+    return [
+        scopedProfilePath(projectPath, name, provider),
+        legacyProfilePath(projectPath, name),
+    ];
+}
+function existingProfilePath(projectPath, name, provider) {
+    const [scoped, legacy] = profileCandidates(projectPath, name, provider);
+    if (fs_1.default.existsSync(scoped))
+        return scoped;
+    if (!fs_1.default.existsSync(legacy))
+        return null;
+    try {
+        const raw = JSON.parse(fs_1.default.readFileSync(legacy, 'utf8'));
+        // Historical unscoped profiles predate multi-provider support and belong
+        // to Claude unless they explicitly declare another provider.
+        return typeof raw.provider === 'string'
+            ? raw.provider === provider ? legacy : null
+            : provider === 'claude' || name === `${provider}-default` ? legacy : null;
+    }
+    catch {
+        // Preserve the editor's ability to surface malformed legacy Claude JSON.
+        return provider === 'claude' ? legacy : null;
+    }
+}
 function jobSnapshotPath(slug, jobId) {
     return path_1.default.join(os_1.default.homedir(), '.specrails', 'projects', slug, 'jobs', jobId, 'profile.json');
 }
@@ -84,8 +114,13 @@ function assertValidName(name) {
  *                  profile itself omits the `provider` field. Defaults to
  *                  `'claude'` so legacy callsites stay backwards compatible.
  */
-function validateStructural(profile, expectedProvider = 'claude') {
-    const providerId = profile.provider ?? expectedProvider;
+function validateStructural(profile, expectedProvider) {
+    const providerId = profile.provider ?? expectedProvider ?? 'claude';
+    if (profile.provider && expectedProvider && profile.provider !== expectedProvider) {
+        throw new ProfileValidationError([
+            `profile provider '${profile.provider}' does not match requested provider '${expectedProvider}'`,
+        ]);
+    }
     if (!(0, providers_1.hasAdapter)(providerId)) {
         throw new ProfileValidationError([
             `profile references unknown provider '${providerId}'`,
@@ -104,15 +139,17 @@ function validateStructural(profile, expectedProvider = 'claude') {
             `profile must include baseline agents for provider '${providerId}': missing ${missing.join(', ')}`,
         ]);
     }
-    // Orchestrator model must be in the adapter's catalog.
-    if (!validModels.has(profile.orchestrator.model)) {
+    // Orchestrator model must be in the adapter catalog, or a safe configured
+    // alias when the adapter explicitly supports them.
+    if (!(0, providers_1.isModelAvailableForAdapter)(adapter, profile.orchestrator.model)) {
         throw new ProfileValidationError([
             `orchestrator.model '${profile.orchestrator.model}' is not valid for provider '${providerId}'. Valid models: ${[...validModels].join(', ')}`,
         ]);
     }
     // Per-agent model (when set) must also be in the catalog.
     for (const agent of profile.agents) {
-        if (agent.model !== undefined && !validModels.has(agent.model)) {
+        if (agent.model !== undefined
+            && !(0, providers_1.isModelAvailableForAdapter)(adapter, agent.model)) {
             throw new ProfileValidationError([
                 `agent '${agent.id}' uses model '${agent.model}' which is not valid for provider '${providerId}'. Valid models: ${[...validModels].join(', ')}`,
             ]);
@@ -149,7 +186,7 @@ function validateStructural(profile, expectedProvider = 'claude') {
         }
     }
 }
-function validateProfile(raw, expectedProvider = 'claude') {
+function validateProfile(raw, expectedProvider) {
     const validate = getValidator();
     if (!validate(raw)) {
         const msgs = (validate.errors || []).map((e) => `${e.instancePath || '/'} ${e.message} (${JSON.stringify(e.params)})`);
@@ -160,11 +197,11 @@ function validateProfile(raw, expectedProvider = 'claude') {
     return profile;
 }
 // ─── Public API ──────────────────────────────────────────────────────────────
-function listProfiles(projectPath) {
+function listProfiles(projectPath, _fallbackProvider = 'claude') {
     const dir = profilesDir(projectPath);
     if (!fs_1.default.existsSync(dir))
         return [];
-    const entries = [];
+    const entries = new Map();
     for (const file of fs_1.default.readdirSync(dir)) {
         if (!file.endsWith('.json'))
             continue;
@@ -172,30 +209,57 @@ function listProfiles(projectPath) {
             continue;
         if (file.startsWith('.'))
             continue;
-        const name = file.slice(0, -'.json'.length);
         const full = path_1.default.join(dir, file);
         try {
             const raw = JSON.parse(fs_1.default.readFileSync(full, 'utf8'));
             const stat = fs_1.default.statSync(full);
-            entries.push({
+            const name = typeof raw?.name === 'string'
+                ? raw.name
+                : file.slice(0, -'.json'.length);
+            const inferredDefaultProvider = typeof name === 'string'
+                ? name.match(/^([a-z0-9][a-z0-9-]*)-default$/)?.[1]
+                : undefined;
+            const provider = typeof raw?.provider === 'string'
+                ? raw.provider
+                : inferredDefaultProvider && (0, providers_1.hasAdapter)(inferredDefaultProvider)
+                    ? inferredDefaultProvider
+                    // Unscoped/provider-less profiles predate multi-provider storage and
+                    // are Claude profiles regardless of which provider is primary today.
+                    // Provider defaults such as `kimi-default.json` are handled by the
+                    // filename inference above. Keeping this aligned with
+                    // existingProfilePath prevents a Kimi-primary project from listing a
+                    // legacy Claude `project-default` as Kimi and then returning 404 when
+                    // it is opened.
+                    : 'claude';
+            const scoped = file === `${provider}--${name}.json`;
+            const key = `${provider}\0${name}`;
+            const candidate = {
                 name,
                 description: typeof raw?.description === 'string' ? raw.description : undefined,
-                isDefault: name === 'default' || name === 'project-default',
+                provider,
+                isDefault: name === 'default'
+                    || name === 'project-default'
+                    || name === `${provider}-default`,
                 updatedAt: Math.floor(stat.mtimeMs),
-            });
+                scoped,
+            };
+            // Prefer the provider-scoped file over a stale legacy duplicate.
+            if (!entries.has(key) || scoped)
+                entries.set(key, candidate);
         }
         catch {
             // Skip unparseable files silently; the caller can surface via getProfile.
         }
     }
-    return entries.sort((a, b) => a.name.localeCompare(b.name));
+    return [...entries.values()]
+        .map(({ scoped: _scoped, ...entry }) => entry)
+        .sort((a, b) => a.name.localeCompare(b.name) || a.provider.localeCompare(b.provider));
 }
 function getProfile(projectPath, name, expectedProvider = 'claude') {
     assertValidName(name);
-    const full = profilePath(projectPath, name);
-    if (!fs_1.default.existsSync(full)) {
+    const full = existingProfilePath(projectPath, name, expectedProvider);
+    if (!full)
         throw new ProfileNotFoundError(name);
-    }
     const raw = JSON.parse(fs_1.default.readFileSync(full, 'utf8'));
     return validateProfile(raw, expectedProvider);
 }
@@ -209,10 +273,9 @@ function getProfile(projectPath, name, expectedProvider = 'claude') {
  */
 function getProfileRaw(projectPath, name, expectedProvider = 'claude') {
     assertValidName(name);
-    const full = profilePath(projectPath, name);
-    if (!fs_1.default.existsSync(full)) {
+    const full = existingProfilePath(projectPath, name, expectedProvider);
+    if (!full)
         throw new ProfileNotFoundError(name);
-    }
     const raw = JSON.parse(fs_1.default.readFileSync(full, 'utf8'));
     try {
         validateProfile(raw, expectedProvider);
@@ -226,8 +289,16 @@ function getProfileRaw(projectPath, name, expectedProvider = 'claude') {
 function createProfile(projectPath, profile, expectedProvider = 'claude') {
     assertValidName(profile.name);
     validateProfile(profile, expectedProvider);
-    const full = profilePath(projectPath, profile.name);
-    if (fs_1.default.existsSync(full)) {
+    const provider = profile.provider ?? expectedProvider;
+    const full = profile.provider || expectedProvider !== 'claude'
+        ? scopedProfilePath(projectPath, profile.name, provider)
+        : legacyProfilePath(projectPath, profile.name);
+    // Core may already own a provider-specific default in the historical
+    // unscoped shape (for example `kimi-default.json`). Treat that as the same
+    // logical profile as Desktop's collision-safe `kimi--kimi-default.json`;
+    // otherwise POST would silently create two defaults. `updateProfile` remains
+    // the explicit migration path from legacy to scoped storage.
+    if (existingProfilePath(projectPath, profile.name, provider)) {
         throw new ProfileConflictError(profile.name);
     }
     fs_1.default.mkdirSync(profilesDir(projectPath), { recursive: true });
@@ -236,21 +307,29 @@ function createProfile(projectPath, profile, expectedProvider = 'claude') {
 function updateProfile(projectPath, profile, expectedProvider = 'claude') {
     assertValidName(profile.name);
     validateProfile(profile, expectedProvider);
-    const full = profilePath(projectPath, profile.name);
-    if (!fs_1.default.existsSync(full)) {
+    const provider = profile.provider ?? expectedProvider;
+    const existing = existingProfilePath(projectPath, profile.name, provider);
+    if (!existing)
         throw new ProfileNotFoundError(profile.name);
-    }
-    fs_1.default.writeFileSync(full, JSON.stringify(profile, null, 2) + '\n', 'utf8');
+    const destination = profile.provider || expectedProvider !== 'claude'
+        ? scopedProfilePath(projectPath, profile.name, provider)
+        : existing;
+    fs_1.default.writeFileSync(destination, JSON.stringify(profile, null, 2) + '\n', 'utf8');
+    // Updating a legacy provider-stamped file migrates it to the collision-safe
+    // scoped filename after the replacement is durably visible.
+    if (destination !== existing && fs_1.default.existsSync(existing))
+        fs_1.default.unlinkSync(existing);
 }
-function deleteProfile(projectPath, name) {
+function deleteProfile(projectPath, name, expectedProvider = 'claude') {
     assertValidName(name);
-    if (name === 'default' || name === 'project-default') {
+    if (name === 'default'
+        || name === 'project-default'
+        || name === `${expectedProvider}-default`) {
         throw new ProfileValidationError(['cannot delete the default profile']);
     }
-    const full = profilePath(projectPath, name);
-    if (!fs_1.default.existsSync(full)) {
+    const full = existingProfilePath(projectPath, name, expectedProvider);
+    if (!full)
         throw new ProfileNotFoundError(name);
-    }
     fs_1.default.unlinkSync(full);
 }
 function duplicateProfile(projectPath, sourceName, newName, expectedProvider = 'claude') {
@@ -262,12 +341,29 @@ function duplicateProfile(projectPath, sourceName, newName, expectedProvider = '
 function renameProfile(projectPath, fromName, toName, expectedProvider = 'claude') {
     // Renaming the default away would leave no default → resolveProfile returns
     // null and rails silently drop to legacy/no-profile mode. Mirror deleteProfile.
-    if (fromName === 'default' || fromName === 'project-default') {
+    if (fromName === 'default'
+        || fromName === 'project-default'
+        || fromName === `${expectedProvider}-default`) {
         throw new ProfileValidationError(['cannot rename the default profile']);
     }
     const source = getProfile(projectPath, fromName, expectedProvider);
     assertValidName(toName);
-    if (fs_1.default.existsSync(profilePath(projectPath, toName))) {
+    if (toName === 'default'
+        || toName === 'project-default'
+        || toName === `${expectedProvider}-default`) {
+        throw new ProfileValidationError(['cannot rename a profile to a reserved default name']);
+    }
+    const provider = source.provider ?? expectedProvider;
+    const sourcePath = existingProfilePath(projectPath, fromName, provider);
+    if (!sourcePath)
+        throw new ProfileNotFoundError(fromName);
+    const dest = source.provider || expectedProvider !== 'claude'
+        ? scopedProfilePath(projectPath, toName, provider)
+        : legacyProfilePath(projectPath, toName);
+    // Collision is logical, not just destination-path based: a Core-authored
+    // legacy `<name>.json` may already represent this provider even when Desktop
+    // would publish the renamed profile as `<provider>--<name>.json`.
+    if (existingProfilePath(projectPath, toName, provider)) {
         throw new ProfileConflictError(toName);
     }
     const renamed = { ...source, name: toName };
@@ -275,12 +371,11 @@ function renameProfile(projectPath, fromName, toName, expectedProvider = 'claude
     // Atomic publish: write to a temp file in the same dir, fsync-rename into
     // place, THEN remove the old file. A crash/unlink failure can no longer
     // leave both files on disk (which listProfiles would surface as duplicates).
-    const dest = profilePath(projectPath, toName);
     const tmp = `${dest}.tmp-${process.pid}`;
     fs_1.default.writeFileSync(tmp, JSON.stringify(renamed, null, 2) + '\n', 'utf8');
     fs_1.default.renameSync(tmp, dest);
     try {
-        fs_1.default.unlinkSync(profilePath(projectPath, fromName));
+        fs_1.default.unlinkSync(sourcePath);
     }
     catch {
         // The new file is fully published; a stale source is at worst a transient
@@ -315,7 +410,24 @@ function resolveProfile(projectPath, explicit, expectedProvider = 'claude') {
             return resolved;
         throw new ProfileNotFoundError(explicit);
     }
-    return tryName('default') ?? tryName('project-default');
+    const fallbacks = expectedProvider === 'claude'
+        ? ['default', 'project-default']
+        : [`${expectedProvider}-default`, 'default', 'project-default'];
+    for (const fallback of fallbacks) {
+        try {
+            const resolved = tryName(fallback);
+            if (resolved)
+                return resolved;
+        }
+        catch (error) {
+            // A legacy unscoped default may belong to another provider. In a mixed
+            // project it must not prevent the selected provider from falling through
+            // to its own alternate default (or legacy mode).
+            if (!(error instanceof ProfileValidationError))
+                throw error;
+        }
+    }
+    return null;
 }
 // ─── Snapshot-per-job ────────────────────────────────────────────────────────
 /**