Make your computer a home for your AI partner. Avibe is the local-first Agent OS: Vibey, its built-in AI partner, works out of the box, and Claude Code, Codex & OpenCode run unchanged beside it — reach them from your browser, phone, or any chat app.
Python agentagent-osaiai-agentsai-partnerchatopsclaudeclaude-codecodexdevtoolsdiscord-botlark-botllmlocal-firstlong-term-memoryopencodeslack-botvibe-codingvibeywechat
import type { TranslationKey } from '@/i18n/types';
import type { Source, SourcePatch } from './types';
import { SOURCE_DISPLAY_NAME_MAX_LENGTH } from './types';
import {
SOURCE_MUTATION_ACTIONS,
type SourceMutationAction,
type SourceMutationImpact,
} from './mutationSettlement';
import { optionalTrimmedTextWithin } from './validation';
/** Management changes a valid Source; repair restores a blocked one. */
export type ManageKind = 'edit_source' | 'delete_source';
export type ManageDestination = 'edit_source_dialog' | 'delete_source_guard';
export const MANAGE_DESTINATION: Record<ManageKind, ManageDestination> = {
edit_source: 'edit_source_dialog',
delete_source: 'delete_source_guard',
};
export const MANAGE_LABEL_KEY: Record<ManageKind, TranslationKey> = {
edit_source: 'settings.models.sourceDetail.manage.edit',
delete_source: 'settings.models.sourceDetail.manage.remove',
};
/** Every persisted Source has the same two management actions. */
export const manageActions = (): ManageKind[] => Object.keys(MANAGE_DESTINATION) as ManageKind[];
/** Only Avibe-held API-key sources own an endpoint that this editor can change. */
export const canEditSourceEndpoint = (source: Source): boolean =>
source.kind === 'api_key'
&& source.protocol !== 'search'
&& source.supply_channel === 'hub'
&& Boolean(source.credential_ref);
export type SourceEditDraft = {
displayName: string;
baseUrl: string;
};
export type ManageGuardPlan = SourceMutationImpact;
export const MANAGE_COMMIT_ACTIONS = SOURCE_MUTATION_ACTIONS;
export type ManageCommitAction = SourceMutationAction;
export const MANAGE_STAGE_KINDS = [
'idle',
'editing',
'submitting_edit',
'confirming_edit',
'edit_failed',
'confirming_delete',
'submitting_delete',
'delete_failed',
'committed_edit',
'committed_delete',
] as const;
export type ManageStageKind = (typeof MANAGE_STAGE_KINDS)[number];
export type ManageStage =
| { kind: 'idle' }
| { kind: 'editing'; draft: SourceEditDraft }
| { kind: 'submitting_edit'; draft: SourceEditDraft; patch: SourcePatch; plan: ManageGuardPlan | null; forced: boolean; surface: 'edit' | 'guard' }
| { kind: 'confirming_edit'; draft: SourceEditDraft; patch: SourcePatch; plan: ManageGuardPlan }
| { kind: 'edit_failed'; draft: SourceEditDraft; patch: SourcePatch; plan: ManageGuardPlan | null; forced: boolean; retryRead: boolean; before: Source }
| { kind: 'confirming_delete'; plan: ManageGuardPlan | null }
| { kind: 'submitting_delete'; plan: ManageGuardPlan | null; forced: boolean }
| { kind: 'delete_failed'; plan: ManageGuardPlan | null; forced: boolean; retryRead: boolean; before: Source }
| { kind: 'committed_edit' }
| { kind: 'committed_delete' };
export type ManageFailureSurface = 'none' | 'edit_dialog' | 'guard_dialog' | 'delete_inline';
type ManageStageTransition<Event> = {
[Kind in ManageStageKind]: (
stage: Extract<ManageStage, { kind: Kind }>,
event: Event,
) => ManageStage;
};
type CancelManageStage = { type: 'cancel' };
type RetryManageStage = { type: 'retry' };
type EditManageDraft = { type: 'edit_draft'; draft: SourceEditDraft };
type DismissUnresolvedManageStage = { type: 'dismiss_unresolved' };
type SettleManageStage = { type: 'settled' };
const keepManageStage = <Stage extends ManageStage>(stage: Stage): Stage => stage;
const idleManageStage = (): ManageStage => ({ kind: 'idle' });
/** Total event authority: a new stage cannot omit any user-driven transition. */
export const MANAGE_STAGE_CANCEL = {
idle: keepManageStage,
editing: idleManageStage,
submitting_edit: keepManageStage,
confirming_edit: (stage) => ({ kind: 'editing', draft: stage.draft }),
edit_failed: (stage) => stage.retryRead ? stage : idleManageStage(),
confirming_delete: idleManageStage,
submitting_delete: keepManageStage,
delete_failed: (stage) => stage.retryRead ? stage : idleManageStage(),
committed_edit: keepManageStage,
committed_delete: keepManageStage,
} satisfies ManageStageTransition<CancelManageStage>;
export const MANAGE_STAGE_RETRY = {
idle: keepManageStage,
editing: keepManageStage,
submitting_edit: keepManageStage,
confirming_edit: (stage) => ({
kind: 'submitting_edit',
draft: stage.draft,
patch: stage.patch,
plan: stage.plan,
forced: true,
surface: 'guard',
}),
edit_failed: (stage) => ({
kind: 'submitting_edit',
draft: stage.draft,
patch: stage.patch,
plan: stage.plan,
forced: stage.forced,
surface: 'edit',
}),
confirming_delete: (stage) => ({ kind: 'submitting_delete', plan: stage.plan, forced: stage.plan !== null }),
submitting_delete: keepManageStage,
delete_failed: (stage) => ({
kind: 'submitting_delete',
plan: stage.plan,
forced: stage.forced,
}),
committed_edit: keepManageStage,
committed_delete: keepManageStage,
} satisfies ManageStageTransition<RetryManageStage>;
export const MANAGE_STAGE_EDIT_DRAFT = {
idle: keepManageStage,
editing: (stage, event) => ({ ...stage, draft: event.draft }),
submitting_edit: keepManageStage,
confirming_edit: keepManageStage,
edit_failed: (stage, event) => ({ ...stage, draft: event.draft }),
confirming_delete: keepManageStage,
submitting_delete: keepManageStage,
delete_failed: keepManageStage,
committed_edit: keepManageStage,
committed_delete: keepManageStage,
} satisfies ManageStageTransition<EditManageDraft>;
export const MANAGE_STAGE_DISMISS_UNRESOLVED = {
idle: keepManageStage,
editing: keepManageStage,
submitting_edit: keepManageStage,
confirming_edit: keepManageStage,
edit_failed: (stage) => stage.retryRead ? idleManageStage() : stage,
confirming_delete: keepManageStage,
submitting_delete: keepManageStage,
delete_failed: (stage) => stage.retryRead ? idleManageStage() : stage,
committed_edit: keepManageStage,
committed_delete: keepManageStage,
} satisfies ManageStageTransition<DismissUnresolvedManageStage>;
/** Settlement may close only a post-commit stage; every earlier announcement is ignored. */
export const MANAGE_STAGE_SETTLED = {
idle: keepManageStage,
editing: keepManageStage,
submitting_edit: keepManageStage,
confirming_edit: keepManageStage,
edit_failed: keepManageStage,
confirming_delete: keepManageStage,
submitting_delete: keepManageStage,
delete_failed: keepManageStage,
committed_edit: idleManageStage,
committed_delete: idleManageStage,
} satisfies ManageStageTransition<SettleManageStage>;
export type ManageStageEvent =
| { type: 'begin_edit'; draft: SourceEditDraft }
| { type: 'begin_delete' }
| { type: 'submit_edit'; draft: SourceEditDraft; patch: SourcePatch; plan: ManageGuardPlan | null; surface: 'edit' | 'guard' }
| { type: 'submit_delete'; plan: ManageGuardPlan | null }
| { type: 'guard_delete'; plan: ManageGuardPlan }
| { type: 'guard_edit'; draft: SourceEditDraft; patch: SourcePatch; plan: ManageGuardPlan }
| { type: 'fail_edit'; draft: SourceEditDraft; patch: SourcePatch; plan: ManageGuardPlan | null; forced: boolean; retryRead: boolean; before: Source }
| { type: 'fail_delete'; plan: ManageGuardPlan | null; forced: boolean; retryRead: boolean; before: Source }
| { type: 'commit'; action: ManageCommitAction }
| { type: 'settled' }
| CancelManageStage
| RetryManageStage
| EditManageDraft
| DismissUnresolvedManageStage;
const applyManageStageTransition = <Event,>(
transitions: ManageStageTransition<Event>,
stage: ManageStage,
event: Event,
): ManageStage => {
const transition = transitions[stage.kind] as (current: ManageStage, currentEvent: Event) => ManageStage;
return transition(stage, event);
};
export const transitionManageStage = (stage: ManageStage, event: ManageStageEvent): ManageStage => {
switch (event.type) {
case 'begin_edit': return { kind: 'editing', draft: event.draft };
case 'begin_delete': return { kind: 'confirming_delete', plan: null };
case 'submit_edit': return {
kind: 'submitting_edit',
draft: event.draft,
patch: event.patch,
plan: event.plan,
forced: event.plan !== null,
surface: event.surface,
};
case 'submit_delete': return {
kind: 'submitting_delete',
plan: event.plan,
forced: event.plan !== null,
};
case 'guard_delete': return { kind: 'confirming_delete', plan: event.plan };
case 'guard_edit': return {
kind: 'confirming_edit',
draft: event.draft,
patch: event.patch,
plan: event.plan,
};
case 'fail_edit': return {
kind: 'edit_failed',
draft: event.draft,
patch: event.patch,
plan: event.plan,
forced: event.forced,
retryRead: event.retryRead,
before: event.before,
};
case 'fail_delete': return {
kind: 'delete_failed',
plan: event.plan,
forced: event.forced,
retryRead: event.retryRead,
before: event.before,
};
case 'commit': return event.action === 'edit'
? { kind: 'committed_edit' }
: { kind: 'committed_delete' };
case 'settled': return applyManageStageTransition(MANAGE_STAGE_SETTLED, stage, event);
case 'cancel': return applyManageStageTransition(MANAGE_STAGE_CANCEL, stage, event);
case 'retry': return applyManageStageTransition(MANAGE_STAGE_RETRY, stage, event);
case 'edit_draft': return applyManageStageTransition(MANAGE_STAGE_EDIT_DRAFT, stage, event);
case 'dismiss_unresolved': return applyManageStageTransition(MANAGE_STAGE_DISMISS_UNRESOLVED, stage, event);
}
};
export const MANAGE_STAGE_FAILURE_SURFACE: Record<ManageStageKind, ManageFailureSurface> = {
idle: 'none',
editing: 'edit_dialog',
submitting_edit: 'edit_dialog',
confirming_edit: 'guard_dialog',
edit_failed: 'edit_dialog',
confirming_delete: 'guard_dialog',
submitting_delete: 'delete_inline',
delete_failed: 'delete_inline',
committed_edit: 'none',
committed_delete: 'none',
};
export type SourceEditInvalidReason =
| 'displayNameRequired'
| 'displayNameTooLong'
| 'displayNameCredential'
| 'baseUrlCredential';
export const SOURCE_EDIT_REASON_KEY: Record<SourceEditInvalidReason, TranslationKey> = {
displayNameRequired: 'settings.models.sourceDetail.edit.validation.displayNameRequired',
displayNameTooLong: 'settings.models.sourceDetail.edit.validation.displayNameTooLong',
displayNameCredential: 'settings.models.sourceDetail.edit.validation.displayNameCredential',
baseUrlCredential: 'settings.models.sourceDetail.edit.validation.baseUrlCredential',
};
export type SourceEditAssessment =
| { valid: true; patch: SourcePatch | null; reason: null }
| { valid: false; patch: null; reason: SourceEditInvalidReason };
// These two overlapping sets intentionally mirror config/v2_config.py. They
// stay separate until the server contract changes with the shared fixture.
const CREDENTIAL_QUERY_KEYS = new Set([
'access_token',
'api_key',
'apikey',
'auth',
'authorization',
'bearer',
'credential',
'key',
'password',
'passwd',
'secret',
'sig',
'signature',
'token',
]);
const CREDENTIAL_QUERY_MARKERS = [
'api_key',
'access_token',
'auth_token',
'token',
'authorization',
'signature',
'secret',
'password',
'credential',
];
const CREDENTIAL_PATTERNS = [
/\b(?:sk|rk|pk|sess|token)[-_][a-z0-9_-]{8,}\b/i,
/\b(?:authorization|api[_ -]?key|access[_ -]?token)\s*[:=]\s*(?:sk[-_][a-z0-9_-]{8,}|[a-z0-9._~+/=-]{16,})/i,
/\bbearer\s+[a-z0-9._~+/=-]{8,}/i,
];
const containsCredentialMaterial = (value: string): boolean =>
CREDENTIAL_PATTERNS.some((pattern) => pattern.test(JSON.stringify(value)));
type BaseUrlAssessment =
| { valid: true; value: string | null }
| { valid: false; reason: Extract<SourceEditInvalidReason, `baseUrl${string}`> };
const assessedEditedBaseUrl = (value: string): BaseUrlAssessment => {
if (!value) return { valid: true, value: null };
if (containsCredentialMaterial(value)) return { valid: false, reason: 'baseUrlCredential' };
let parsed: URL;
try {
parsed = new URL(value);
} catch {
return { valid: true, value };
}
for (const key of parsed.searchParams.keys()) {
const normalized = key.trim().toLowerCase().replace(/[-.]/g, '_');
if (
CREDENTIAL_QUERY_KEYS.has(normalized)
|| CREDENTIAL_QUERY_MARKERS.some((marker) => normalized.includes(marker))
) return { valid: false, reason: 'baseUrlCredential' };
}
// The browser owns only the warning that prevents a user from persisting a
// secret. URL acceptance and normalization belong entirely to the server.
return { valid: true, value };
};
/** Pre-filter an actual edit and diff without claiming server target policy. */
export const assessSourceEdit = (source: Source, draft: SourceEditDraft): SourceEditAssessment => {
const displayName = draft.displayName.trim();
if (!displayName) return { valid: false, patch: null, reason: 'displayNameRequired' };
if (!optionalTrimmedTextWithin(draft.displayName, SOURCE_DISPLAY_NAME_MAX_LENGTH)) {
return { valid: false, patch: null, reason: 'displayNameTooLong' };
}
if (containsCredentialMaterial(displayName)) {
return { valid: false, patch: null, reason: 'displayNameCredential' };
}
const patch: SourcePatch = {};
if (displayName !== source.display_name) patch.display_name = displayName;
if (canEditSourceEndpoint(source)) {
const baseUrl = draft.baseUrl.trim();
if (baseUrl !== (source.base_url ?? '')) {
const endpoint = assessedEditedBaseUrl(baseUrl);
if (!endpoint.valid) return { valid: false, patch: null, reason: endpoint.reason };
patch.base_url = endpoint.value;
}
}
return { valid: true, patch: Object.keys(patch).length > 0 ? patch : null, reason: null };
};