@undefineds.co/linx 0.3.5 → 0.3.8

package/vendor/agent-runtime/dist/auto-mode.js

@@ -40,6 +40,87 @@ export function autoModeApprovalRequestMessage(request) {
 export const DEFAULT_AUTO_MODE_SECRETARY_REACTION_WINDOW_MS = 5_000;
 export const MIN_AUTO_MODE_SECRETARY_REACTION_WINDOW_MS = 5_000;
 export const MAX_AUTO_MODE_SECRETARY_REACTION_WINDOW_MS = 60_000;
+export function resolveAutoModeCommandRoute(input) {
+    const text = normalizeAutoModeCommandText(input);
+    if (!text) {
+        return null;
+    }
+    const autoRoute = resolveAutoModeAutoControlCommand(text);
+    if (autoRoute) {
+        return autoRoute;
+    }
+    return resolveAutoModePeerCommand(text);
+}
+export function resolveAutoModePeerCommand(input) {
+    const text = normalizeAutoModeCommandText(input);
+    if (text !== '/goal' && !text.startsWith('/goal ')) {
+        return null;
+    }
+    const argument = text.slice('/goal'.length).trim();
+    const goalMode = inferSecretaryGoalModeFromGoalPeerCommand(argument);
+    return {
+        kind: 'peer-command',
+        targetRole: 'peer-command',
+        command: 'goal',
+        text,
+        ...(goalMode === undefined ? {} : { secretaryBehavior: { goalMode } }),
+    };
+}
+function resolveAutoModeAutoControlCommand(text) {
+    if (text === '/auto' || text === '/auto status') {
+        return {
+            kind: 'control-command',
+            targetRole: 'control-command',
+            command: 'auto',
+            text,
+            auto: { action: 'status' },
+        };
+    }
+    if (text === '/auto on') {
+        return {
+            kind: 'control-command',
+            targetRole: 'control-command',
+            command: 'auto',
+            text,
+            auto: { action: 'set', enabled: true },
+        };
+    }
+    if (text === '/auto off') {
+        return {
+            kind: 'control-command',
+            targetRole: 'control-command',
+            command: 'auto',
+            text,
+            auto: { action: 'set', enabled: false },
+        };
+    }
+    if (text.startsWith('/auto ')) {
+        const initialInput = text.slice('/auto'.length).trim();
+        if (initialInput && initialInput !== 'on' && initialInput !== 'off' && initialInput !== 'status') {
+            return {
+                kind: 'control-command',
+                targetRole: 'control-command',
+                command: 'auto',
+                text,
+                auto: { action: 'set', enabled: true, initialInput },
+            };
+        }
+    }
+    return null;
+}
+function normalizeAutoModeCommandText(input) {
+    return typeof input === 'string' ? input.trim() : '';
+}
+function inferSecretaryGoalModeFromGoalPeerCommand(argument) {
+    if (!argument || argument === 'status') {
+        return undefined;
+    }
+    const firstToken = argument.split(/\s+/, 1)[0]?.toLowerCase();
+    if (firstToken === 'pause' || firstToken === 'close' || firstToken === 'cancel') {
+        return false;
+    }
+    return true;
+}
 export const AUTO_MODE_HOME_DIRNAME = 'auto-mode';
 export const AUTO_MODE_SESSIONS_DIRNAME = 'sessions';
 export const AUTO_MODE_SESSION_FILE_NAME = 'session.json';
@@ -208,6 +289,119 @@ export function normalizeAutoModeApprovalOptions(value) {
     })
         .filter((option) => option !== null);
 }
+export function parseAutoModeApprovalOptions(value) {
+    if (Array.isArray(value)) {
+        return normalizeAutoModeApprovalOptions(value);
+    }
+    if (typeof value !== 'string' || !value.trim()) {
+        return [];
+    }
+    try {
+        const parsed = JSON.parse(value);
+        return normalizeAutoModeApprovalOptions(parsed);
+    }
+    catch {
+        return [];
+    }
+}
+export function encodeAutoModeApprovalOptions(options) {
+    return options && options.length > 0 ? JSON.stringify(options) : undefined;
+}
+export function buildAutoModeApprovalDecisionReason(options, note) {
+    const input = typeof options === 'string' ? { decision: options, note } : options;
+    const selectedOptionId = input.selectedOption?.optionId ?? input.selectedOptionId;
+    const selectedLabel = input.selectedOption?.label ?? input.selectedLabel;
+    return JSON.stringify({
+        ...(input.source?.trim() ? { source: input.source.trim() } : {}),
+        ...(input.decision ? { decision: input.decision } : {}),
+        ...(input.note?.trim() ? { note: input.note.trim() } : {}),
+        ...(selectedOptionId?.trim() ? { selectedOptionId: selectedOptionId.trim() } : {}),
+        ...(selectedLabel?.trim() ? { selectedLabel: selectedLabel.trim() } : {}),
+    });
+}
+export function parseAutoModeApprovalDecisionReason(value) {
+    if (typeof value !== 'string' || !value.trim()) {
+        return null;
+    }
+    try {
+        const parsed = JSON.parse(value);
+        const record = recordFromUnknown(parsed);
+        if (!record) {
+            return null;
+        }
+        const decision = normalizeAutoModeApprovalDecision(record.decision);
+        const nested = parseAutoModeApprovalDecisionReason(record.note);
+        const source = stringFromUnknown(record.source);
+        const note = stringFromUnknown(record.note);
+        const selectedOptionId = stringFromUnknown(record.selectedOptionId) ?? nested?.selectedOptionId;
+        const selectedLabel = stringFromUnknown(record.selectedLabel) ?? nested?.selectedLabel;
+        if (!source && !decision && !note && !selectedOptionId && !selectedLabel) {
+            return null;
+        }
+        return {
+            ...(source ? { source } : {}),
+            ...(decision ? { decision } : {}),
+            ...(note ? { note } : {}),
+            ...(selectedOptionId ? { selectedOptionId } : {}),
+            ...(selectedLabel ? { selectedLabel } : {}),
+        };
+    }
+    catch {
+        return null;
+    }
+}
+export function autoModeApprovalDecisionForOption(option) {
+    if (option.kind === 'allow_for_session') {
+        return 'accept_for_session';
+    }
+    if (option.kind === 'allow_always') {
+        return 'accept_always';
+    }
+    if (option.kind === 'reject_once' || option.kind === 'reject_always') {
+        return 'decline';
+    }
+    if (option.kind === 'cancel') {
+        return 'cancel';
+    }
+    return 'accept';
+}
+export function autoModeApprovalDecisionForStoredApproval(input) {
+    if (input.status === 'pending') {
+        return null;
+    }
+    const parsed = parseAutoModeApprovalDecisionReason(input.reason);
+    if (input.status === 'rejected') {
+        return parsed?.decision === 'cancel' ? 'cancel' : 'decline';
+    }
+    const option = parsed?.selectedOptionId
+        ? parseAutoModeApprovalOptions(input.approvalOptions).find((entry) => entry.optionId === parsed.selectedOptionId)
+        : null;
+    if (option) {
+        return autoModeApprovalDecisionForOption(option);
+    }
+    if (parsed?.decision === 'accept_for_session') {
+        return 'accept_for_session';
+    }
+    if (parsed?.decision === 'accept_always') {
+        return 'accept_always';
+    }
+    if (parsed?.decision === 'decline' || parsed?.decision === 'cancel') {
+        return parsed.decision;
+    }
+    return input.status === 'approved' ? 'accept' : null;
+}
+export function shouldMaterializeAutoModeGrant(decision) {
+    return decision === 'accept_for_session' || decision === 'accept_always';
+}
+export function autoModeGrantScopeForDecision(decision) {
+    if (decision === 'accept_for_session') {
+        return 'session';
+    }
+    if (decision === 'accept_always') {
+        return 'durable';
+    }
+    return null;
+}
 function normalizeDurationMs(value, unit) {
     const numeric = typeof value === 'number'
         ? value
@@ -274,10 +468,12 @@ function selectAcpPermissionOption(options, decision) {
         return undefined;
     }
     const preferredKinds = decision === 'accept'
-        ? ['allow_once', 'allow_always']
+        ? ['allow_once', 'allow_for_session', 'allow_always']
         : decision === 'accept_for_session'
-            ? ['allow_always', 'allow_once']
-            : ['reject_once', 'reject_always'];
+            ? ['allow_for_session', 'allow_always', 'allow_once']
+            : decision === 'accept_always'
+                ? ['allow_always', 'allow_for_session', 'allow_once']
+                : ['reject_once', 'reject_always'];
     for (const kind of preferredKinds) {
         const match = options.find((option) => option.kind === kind && typeof option.optionId === 'string');
         if (match && typeof match.optionId === 'string') {
@@ -307,11 +503,11 @@ export function createAutoModeSessionId(options = {}) {
     const stamp = now.toISOString().replace(/[:.]/g, '-');
     return `auto_${stamp}_${randomId}`;
 }
-export function normalizeAutoModeCredentialSource(_source) {
-    return 'cloud';
+export function normalizeAutoModeCredentialSource(source) {
+    return source === 'local' ? 'local' : 'cloud';
 }
-export function shouldAttemptCloudCredentialProbe(_requestedSource, _localAuthStatus) {
-    return true;
+export function shouldAttemptCloudCredentialProbe(requestedSource, _localAuthStatus) {
+    return normalizeAutoModeCredentialSource(requestedSource) === 'cloud';
 }
 export function formatAutoModeAutoFallbackMessage(localMessage, detail) {
     return `${localMessage} Cloud credential fallback unavailable: ${detail}`;
@@ -319,6 +515,20 @@ export function formatAutoModeAutoFallbackMessage(localMessage, detail) {
 export function resolveAutoModeCredentialSourceResolution(input) {
     const requestedSource = normalizeAutoModeCredentialSource(input.requestedSource);
     const cloudCredentialProbe = input.cloudCredentialProbe;
+    if (requestedSource === 'local') {
+        if (input.localAuthStatus.state === 'unauthenticated') {
+            return {
+                requestedSource,
+                authStatus: input.localAuthStatus,
+                error: input.localAuthStatus.message ?? input.defaultLocalMessage ?? 'Local backend authentication unavailable.',
+            };
+        }
+        return {
+            requestedSource,
+            resolvedSource: 'local',
+            authStatus: input.localAuthStatus,
+        };
+    }
     if (cloudCredentialProbe?.status === 'available') {
         return {
             requestedSource,
@@ -333,27 +543,22 @@ export function resolveAutoModeCredentialSourceResolution(input) {
     };
 }
 export function resolveAutoModeAutoApprovalDecision(input) {
-    const { mode, request } = input;
+    const { request } = input;
+    const autoEnabled = isAutoModeSecretaryControlEnabled(input);
     if (request.kind === 'command-approval') {
-        if (mode === 'auto') {
+        if (autoEnabled) {
             return 'accept_for_session';
         }
-        if (mode === 'smart' && isTrustedAutoModeCommand(request.command)) {
-            return 'accept';
-        }
         return null;
     }
     if (request.kind === 'file-change-approval') {
-        if (mode === 'auto') {
+        if (autoEnabled) {
             return 'accept_for_session';
         }
-        if (mode === 'smart') {
-            return 'accept';
-        }
         return null;
     }
     if (request.kind === 'permissions-approval') {
-        if (mode === 'auto') {
+        if (autoEnabled) {
             return 'accept_for_session';
         }
         return null;
@@ -361,14 +566,15 @@ export function resolveAutoModeAutoApprovalDecision(input) {
     return null;
 }
 export function createFallbackAutoModeSecretaryRecommendation(input) {
-    if (input.mode === 'manual' || input.request.kind === 'user-input') {
+    if (!isAutoModeSecretaryControlEnabled(input) || input.request.kind === 'user-input') {
         return null;
     }
     const decision = resolveAutoModeAutoApprovalDecision({
         mode: input.mode,
+        autoEnabled: input.autoEnabled,
         request: input.request,
     });
-    const secretaryDecision = decision === 'accept_for_session' ? 'accept' : decision;
+    const secretaryDecision = normalizeAutoModeDecisionForSecretary(decision);
     if (!secretaryDecision) {
         return null;
     }
@@ -376,7 +582,7 @@ export function createFallbackAutoModeSecretaryRecommendation(input) {
         kind: input.request.kind,
         canAutoDecide: true,
         decision: secretaryDecision,
-        confidence: input.mode === 'auto' ? 0.7 : 0.6,
+        confidence: 0.7,
         reason: 'Matched local fallback policy while AI secretary was unavailable.',
         reactionWindowMs: 0,
         source: 'fallback',
@@ -444,6 +650,9 @@ export function autoModeApprovalDecisionLabel(decision) {
     if (decision === 'accept_for_session') {
         return 'Grant';
     }
+    if (decision === 'accept_always') {
+        return 'Always allow';
+    }
     if (decision === 'decline') {
         return 'Deny';
     }
@@ -527,7 +736,7 @@ function normalizeSecretaryApprovalDecision(value) {
         return undefined;
     }
     const normalized = value.trim().toLowerCase().replace(/-/g, '_');
-    if (['accept', 'allow', 'allow_once', 'approve', 'yes', 'accept_for_session', 'allow_always', 'grant', 'session', 'approve_for_session'].includes(normalized)) {
+    if (['accept', 'allow', 'allow_once', 'approve', 'yes', 'accept_for_session', 'accept_always', 'allow_for_session', 'allow_always', 'grant', 'session', 'approve_for_session'].includes(normalized)) {
         return 'accept';
     }
     if (['decline', 'deny', 'reject', 'reject_once', 'reject_always', 'no'].includes(normalized)) {
@@ -538,6 +747,37 @@ function normalizeSecretaryApprovalDecision(value) {
     }
     return undefined;
 }
+function normalizeAutoModeDecisionForSecretary(decision) {
+    if (decision === 'accept' || decision === 'accept_for_session' || decision === 'accept_always') {
+        return 'accept';
+    }
+    if (decision === 'decline' || decision === 'cancel') {
+        return decision;
+    }
+    return undefined;
+}
+function normalizeAutoModeApprovalDecision(value) {
+    if (typeof value !== 'string') {
+        return undefined;
+    }
+    const normalized = value.trim().toLowerCase().replace(/-/g, '_');
+    if (['accept', 'allow', 'allow_once', 'approve', 'yes'].includes(normalized)) {
+        return 'accept';
+    }
+    if (['accept_for_session', 'allow_for_session', 'session', 'approve_for_session'].includes(normalized)) {
+        return 'accept_for_session';
+    }
+    if (['accept_always', 'allow_always', 'grant', 'always', 'approve_always'].includes(normalized)) {
+        return 'accept_always';
+    }
+    if (['decline', 'deny', 'reject', 'reject_once', 'reject_always', 'no'].includes(normalized)) {
+        return 'decline';
+    }
+    if (['cancel', 'abort'].includes(normalized)) {
+        return 'cancel';
+    }
+    return undefined;
+}
 function parseJsonObjectFromText(text) {
     const trimmed = text.trim();
     if (!trimmed) {
@@ -630,6 +870,9 @@ function normalizeAutoModeAuthText(value, depth = 0) {
     ]);
 }
 export function getAutoModeAuthLoginCommand(backend) {
+    if (backend === 'linx') {
+        return null;
+    }
     if (backend === 'claude') {
         return 'claude auth login';
     }
@@ -640,11 +883,18 @@ export function getAutoModeAuthLoginCommand(backend) {
 }
 export function formatAutoModeBackendAuthMessage(backend, detail) {
     const command = getAutoModeAuthLoginCommand(backend);
-    const label = backend === 'claude'
-        ? 'Claude Code'
-        : backend === 'codebuddy'
-            ? 'CodeBuddy Code'
-            : 'Codex';
+    const label = backend === 'linx'
+        ? 'LinX'
+        : backend === 'claude'
+            ? 'Claude Code'
+            : backend === 'codebuddy'
+                ? 'CodeBuddy Code'
+                : 'Codex';
+    if (backend === 'linx') {
+        return detail
+            ? `${label} backend is unavailable. Native message: ${detail}`
+            : `${label} backend is unavailable.`;
+    }
     if (backend === 'codebuddy') {
         return detail
             ? `${label} is not authenticated. Open \`codebuddy\` and complete login first. Native message: ${detail}`
@@ -821,12 +1071,13 @@ export function normalizeCodexAppServerInteractionRequest(message) {
     return null;
 }
 export function resolveAutoModeInteractionAutoResponse(input) {
-    const { mode, request } = input;
+    const { request } = input;
     if (request.kind === 'user-input' || request.kind === 'codex-approval') {
         return null;
     }
     const decision = resolveAutoModeAutoApprovalDecision({
-        mode,
+        mode: input.mode,
+        autoEnabled: input.autoEnabled,
         request,
     });
     if (!decision) {
@@ -834,12 +1085,17 @@ export function resolveAutoModeInteractionAutoResponse(input) {
     }
     return buildCodexApprovalResponse(request, decision);
 }
+function isAutoModeSecretaryControlEnabled(input) {
+    return typeof input.autoEnabled === 'boolean'
+        ? input.autoEnabled
+        : input.mode === 'auto';
+}
 export function buildCodexApprovalResponse(request, decision) {
     if (request.kind === 'permissions-approval') {
         if (decision === 'accept') {
             return { permissions: request.permissions, scope: 'turn' };
         }
-        if (decision === 'accept_for_session') {
+        if (decision === 'accept_for_session' || decision === 'accept_always') {
             return { permissions: request.permissions, scope: 'session' };
         }
         return { permissions: {}, scope: 'turn' };
@@ -848,7 +1104,7 @@ export function buildCodexApprovalResponse(request, decision) {
         if (decision === 'accept') {
             return { decision: 'approved' };
         }
-        if (decision === 'accept_for_session') {
+        if (decision === 'accept_for_session' || decision === 'accept_always') {
             return { decision: 'approved_for_session' };
         }
         if (decision === 'cancel') {
@@ -859,7 +1115,7 @@ export function buildCodexApprovalResponse(request, decision) {
     if (decision === 'accept') {
         return { decision: 'accept' };
     }
-    if (decision === 'accept_for_session') {
+    if (decision === 'accept_for_session' || decision === 'accept_always') {
         return { decision: 'acceptForSession' };
     }
     if (decision === 'cancel') {
@@ -1380,6 +1636,7 @@ export function buildAutoModeThreadMetadata(record) {
         runtime: record.runtime,
         transport: record.transport,
         mode: record.mode,
+        ...(record.autoEnabled !== undefined ? { autoEnabled: record.autoEnabled } : {}),
         ...(record.goalMode !== undefined ? { goalMode: record.goalMode } : {}),
         cwd: record.cwd,
         model: record.model,

package/vendor/agent-runtime/dist/control-plane.d.ts

@@ -0,0 +1,28 @@
+export type LinxSessionControlSurface = 'cli' | 'app' | 'desktop' | 'runtime';
+export interface LinxSessionControlState {
+    autoEnabled?: boolean;
+    symphonyEnabled?: boolean;
+    updatedAt: string;
+    updatedBy?: LinxSessionControlSurface | string;
+}
+export interface LinxSessionControlMetadata {
+    controlPlane: {
+        linxSession: LinxSessionControlState;
+    };
+}
+export declare function buildLinxSessionControlState(input: {
+    autoEnabled?: boolean;
+    symphonyEnabled?: boolean;
+    updatedAt?: Date | string;
+    updatedBy?: LinxSessionControlSurface | string;
+}): LinxSessionControlState;
+export declare function buildLinxSessionControlMetadata(input: {
+    autoEnabled?: boolean;
+    symphonyEnabled?: boolean;
+    updatedAt?: Date | string;
+    updatedBy?: LinxSessionControlSurface | string;
+}): LinxSessionControlMetadata;
+export declare function mergeLinxSessionControlMetadata(metadata: Record<string, unknown> | null | undefined, state: LinxSessionControlState): Record<string, unknown>;
+export declare function readLinxSessionControlMetadata(metadata: Record<string, unknown> | null | undefined): LinxSessionControlState | null;
+export declare function resolveLinxSessionAutoEnabled(metadata: Record<string, unknown> | null | undefined): boolean | null;
+export declare function resolveLinxSessionSymphonyEnabled(metadata: Record<string, unknown> | null | undefined): boolean | null;

package/vendor/agent-runtime/dist/control-plane.js

@@ -0,0 +1,79 @@
+export function buildLinxSessionControlState(input) {
+    return {
+        ...(input.autoEnabled !== undefined ? { autoEnabled: input.autoEnabled } : {}),
+        ...(input.symphonyEnabled !== undefined ? { symphonyEnabled: input.symphonyEnabled } : {}),
+        updatedAt: toControlStateIsoString(input.updatedAt ?? new Date()),
+        ...(input.updatedBy ? { updatedBy: input.updatedBy } : {}),
+    };
+}
+export function buildLinxSessionControlMetadata(input) {
+    return {
+        controlPlane: {
+            linxSession: buildLinxSessionControlState(input),
+        },
+    };
+}
+export function mergeLinxSessionControlMetadata(metadata, state) {
+    const existing = isRecord(metadata) ? metadata : {};
+    const existingControlPlane = isRecord(existing.controlPlane) ? existing.controlPlane : {};
+    const existingSession = isRecord(existingControlPlane.linxSession) ? existingControlPlane.linxSession : {};
+    return {
+        ...existing,
+        controlPlane: {
+            ...existingControlPlane,
+            linxSession: {
+                ...existingSession,
+                ...state,
+            },
+        },
+    };
+}
+export function readLinxSessionControlMetadata(metadata) {
+    if (!isRecord(metadata)) {
+        return null;
+    }
+    const controlPlane = isRecord(metadata.controlPlane) ? metadata.controlPlane : null;
+    const session = controlPlane && isRecord(controlPlane.linxSession) ? controlPlane.linxSession : null;
+    if (!session) {
+        return null;
+    }
+    const updatedAt = typeof session.updatedAt === 'string'
+        ? session.updatedAt
+        : undefined;
+    const autoEnabled = typeof session.autoEnabled === 'boolean'
+        ? session.autoEnabled
+        : undefined;
+    const symphonyEnabled = typeof session.symphonyEnabled === 'boolean'
+        ? session.symphonyEnabled
+        : undefined;
+    const updatedBy = typeof session.updatedBy === 'string'
+        ? session.updatedBy
+        : undefined;
+    if (autoEnabled === undefined && symphonyEnabled === undefined && !updatedAt && !updatedBy) {
+        return null;
+    }
+    return {
+        ...(autoEnabled !== undefined ? { autoEnabled } : {}),
+        ...(symphonyEnabled !== undefined ? { symphonyEnabled } : {}),
+        updatedAt: updatedAt ? toControlStateIsoString(updatedAt) : new Date(0).toISOString(),
+        ...(updatedBy ? { updatedBy } : {}),
+    };
+}
+export function resolveLinxSessionAutoEnabled(metadata) {
+    const state = readLinxSessionControlMetadata(metadata);
+    return typeof state?.autoEnabled === 'boolean' ? state.autoEnabled : null;
+}
+export function resolveLinxSessionSymphonyEnabled(metadata) {
+    const state = readLinxSessionControlMetadata(metadata);
+    return typeof state?.symphonyEnabled === 'boolean' ? state.symphonyEnabled : null;
+}
+function toControlStateIsoString(value) {
+    if (value instanceof Date) {
+        return value.toISOString();
+    }
+    const date = new Date(value);
+    return Number.isNaN(date.getTime()) ? new Date().toISOString() : date.toISOString();
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null;
+}