@undefineds.co/linx 0.3.20 → 0.3.23

package/vendor/agent-runtime/dist/workspace.d.ts

@@ -0,0 +1,61 @@
+export type RuntimeWorkspaceKind = 'local-folder' | 'local-worktree' | 'pod-container';
+export type AgentWorkspaceKind = 'folder' | 'git' | 'worktree';
+export interface AgentWorkspaceEnvironment {
+    kind: 'local-shell' | 'remote-container' | 'cloud-runner' | 'backend-runtime' | 'unknown';
+    id?: string;
+    label?: string;
+    runtime?: string;
+}
+export interface AgentWorkspace {
+    /**
+     * Stable container identity.
+     *
+     * - Solid Pod containers should use their dereferenceable HTTP(S) LDP IRI.
+     * - Device-local containers should use a device-scoped URI such as
+     *   `linx://device-0000/Users/alice/repo`.
+     *
+     * Runtime adapters may derive a process-local path from this value, but the
+     * path is not the shared identity.
+     */
+    container?: string;
+    path?: string;
+    kind: AgentWorkspaceKind;
+    repository?: string;
+    branch?: string;
+    worktree?: string;
+    baseRevision?: string;
+    environment?: AgentWorkspaceEnvironment;
+}
+export interface RuntimeWorkspaceInput {
+    workspaceKind?: unknown;
+    container?: string | null;
+    repoPath?: string | null;
+    folderPath?: string | null;
+    baseRef?: string | null;
+    branch?: string | null;
+}
+export interface NormalizedRuntimeWorkspaceInput {
+    workspaceKind: RuntimeWorkspaceKind;
+    container?: string;
+    repoPath?: string;
+    folderPath?: string;
+    baseRef: string;
+    branch?: string;
+}
+export interface NormalizeRuntimeWorkspaceOptions {
+    normalizeLocalPath?: (value?: string | null) => string;
+    defaultBaseRef?: string;
+}
+export interface RuntimeWorkspaceSessionLike {
+    cwd?: string | null;
+    repoPath?: string | null;
+    folderPath?: string | null;
+    container?: string | null;
+}
+export declare function isRuntimeWorkspaceKind(value: unknown): value is RuntimeWorkspaceKind;
+export declare function isHttpContainerRef(value?: string | null): boolean;
+export declare const isHttpWorkspaceRef: typeof isHttpContainerRef;
+export declare function inferRuntimeWorkspaceKind(input: RuntimeWorkspaceInput, options?: NormalizeRuntimeWorkspaceOptions): RuntimeWorkspaceKind;
+export declare function normalizeRuntimeWorkspaceInput(input: RuntimeWorkspaceInput, options?: NormalizeRuntimeWorkspaceOptions): NormalizedRuntimeWorkspaceInput;
+export declare function isRuntimeSessionInWorkspace(session: RuntimeWorkspaceSessionLike, workspacePath: string, options?: NormalizeRuntimeWorkspaceOptions): boolean;
+export declare function filterRuntimeSessionsForWorkspace<T extends RuntimeWorkspaceSessionLike>(sessions: T[], workspacePath: string, options?: NormalizeRuntimeWorkspaceOptions): T[];

package/vendor/agent-runtime/dist/workspace.js

@@ -0,0 +1,81 @@
+function trim(value) {
+    return value?.trim() || '';
+}
+function normalizeLocalPath(value) {
+    return trim(value);
+}
+export function isRuntimeWorkspaceKind(value) {
+    return value === 'local-folder' || value === 'local-worktree' || value === 'pod-container';
+}
+export function isHttpContainerRef(value) {
+    const candidate = trim(value);
+    if (!candidate)
+        return false;
+    try {
+        const url = new URL(candidate);
+        return url.protocol === 'http:' || url.protocol === 'https:';
+    }
+    catch {
+        return false;
+    }
+}
+export const isHttpWorkspaceRef = isHttpContainerRef;
+export function inferRuntimeWorkspaceKind(input, options = {}) {
+    if (isRuntimeWorkspaceKind(input.workspaceKind)) {
+        return input.workspaceKind;
+    }
+    const normalize = options.normalizeLocalPath ?? normalizeLocalPath;
+    const repoPath = normalize(input.repoPath);
+    if (isHttpContainerRef(input.container) && !repoPath) {
+        return 'pod-container';
+    }
+    const folderPath = normalize(input.folderPath);
+    return repoPath && folderPath && folderPath !== repoPath ? 'local-worktree' : 'local-folder';
+}
+export function normalizeRuntimeWorkspaceInput(input, options = {}) {
+    const normalize = options.normalizeLocalPath ?? normalizeLocalPath;
+    const workspaceKind = inferRuntimeWorkspaceKind(input, options);
+    const container = trim(input.container) || undefined;
+    const repoPath = normalize(input.repoPath) || undefined;
+    const folderPathInput = normalize(input.folderPath) || undefined;
+    const baseRef = trim(input.baseRef) || options.defaultBaseRef || 'HEAD';
+    const branch = trim(input.branch) || undefined;
+    if (workspaceKind === 'pod-container') {
+        if (!container || !isHttpContainerRef(container)) {
+            throw new Error('Pod workspace session requires an http(s) container.');
+        }
+        return {
+            workspaceKind,
+            container,
+            repoPath,
+            folderPath: folderPathInput,
+            baseRef,
+            branch,
+        };
+    }
+    if (!repoPath) {
+        throw new Error('Local runtime session requires repoPath.');
+    }
+    const folderPath = folderPathInput || repoPath;
+    return {
+        workspaceKind: folderPath !== repoPath ? 'local-worktree' : 'local-folder',
+        container,
+        repoPath,
+        folderPath,
+        baseRef,
+        branch,
+    };
+}
+export function isRuntimeSessionInWorkspace(session, workspacePath, options = {}) {
+    const normalize = options.normalizeLocalPath ?? normalizeLocalPath;
+    const expected = normalize(workspacePath);
+    if (!expected)
+        return false;
+    const candidates = [session.cwd, session.folderPath, session.repoPath]
+        .map((value) => normalize(value))
+        .filter(Boolean);
+    return candidates.some((candidate) => candidate === expected);
+}
+export function filterRuntimeSessionsForWorkspace(sessions, workspacePath, options = {}) {
+    return sessions.filter((session) => isRuntimeSessionInWorkspace(session, workspacePath, options));
+}

package/vendor/agent-runtime/package.json

@@ -6,15 +6,19 @@
     ".": "./dist/index.js",
     "./acp": "./dist/acp.js",
     "./auto-mode": "./dist/auto-mode.js",
+    "./chat-reconciler": "./dist/chat-reconciler.js",
     "./companion-model": "./dist/companion-model.js",
     "./control-plane": "./dist/control-plane.js",
     "./file-sync": "./dist/file-sync.js",
+    "./matrix-client": "./dist/matrix-client.js",
+    "./pod-resource-identity": "./dist/pod-resource-identity.js",
     "./reconciler": "./dist/reconciler.js",
     "./runtime": "./dist/runtime.js",
     "./symphony": "./dist/symphony.js",
     "./sync": "./dist/sync.js",
     "./thread-reconciler-controller": "./dist/thread-reconciler-controller.js",
     "./turn-controller": "./dist/turn-controller.js",
-    "./wake-scheduler": "./dist/wake-scheduler.js"
+    "./wake-scheduler": "./dist/wake-scheduler.js",
+    "./workspace": "./dist/workspace.js"
   }
 }

package/vendor/stores/dist/current-pod-base.d.ts

@@ -0,0 +1,2 @@
+import type { SolidDatabase } from '@undefineds.co/models';
+export declare function resolveCurrentPodBaseUrl(db: SolidDatabase): string | null;

package/vendor/stores/dist/current-pod-base.js

@@ -0,0 +1,14 @@
+export function resolveCurrentPodBaseUrl(db) {
+    const podUrl = db.getDialect?.()?.getPodUrl?.() ?? db.getPodUrl?.();
+    return normalizePodBaseUrl(podUrl);
+}
+function normalizePodBaseUrl(url) {
+    if (typeof url !== 'string') {
+        return null;
+    }
+    const trimmed = url.trim();
+    if (!trimmed) {
+        return null;
+    }
+    return trimmed.replace(/\/+$/, '');
+}

package/vendor/stores/dist/exact-records.d.ts

@@ -0,0 +1,7 @@
+import type { PodResource, SolidDatabase } from '@undefineds.co/drizzle-solid';
+type ExactRecordTarget = string | Record<string, unknown> | null | undefined;
+type ExactPodResource = PodResource<any>;
+export declare function findExactRecord<T>(db: SolidDatabase, resource: ExactPodResource, target: ExactRecordTarget): Promise<T | null>;
+export declare function updateExactRecord(db: SolidDatabase, resource: ExactPodResource, target: ExactRecordTarget, updates: Record<string, unknown>): Promise<void>;
+export declare function deleteExactRecord(db: SolidDatabase, resource: ExactPodResource, target: ExactRecordTarget): Promise<void>;
+export {};

package/vendor/stores/dist/exact-records.js

@@ -0,0 +1,87 @@
+import { asBaseRelativeResourceId, requireRowResourceId } from '../../agent-runtime/dist/pod-resource-identity.js';
+import { assertCurrentPodBaseUrl, assertIriBelongsToCurrentPod, assertUpdateValuesBelongToCurrentPod } from './pod-write-guard.js';
+const ABSOLUTE_IRI = /^[a-zA-Z][a-zA-Z\d+.-]*:/;
+const INTERNAL_FIELDS = new Set(['id', '@id', 'subject', 'uri', 'source']);
+export async function findExactRecord(db, resource, target) {
+    const locatorDb = db;
+    const id = resolveRecordId(target);
+    if (id && typeof locatorDb.findById === 'function') {
+        return locatorDb.findById(resource, id);
+    }
+    const iri = resolveRecordIri(target);
+    if (iri && typeof locatorDb.findByIri === 'function') {
+        return locatorDb.findByIri(resource, iri);
+    }
+    return null;
+}
+export async function updateExactRecord(db, resource, target, updates) {
+    const locatorDb = db;
+    const payload = sanitizeUpdatePayload(updates);
+    assertCurrentPodBaseUrl(db, 'update');
+    assertUpdateValuesBelongToCurrentPod(db, payload);
+    const id = resolveRecordId(target);
+    if (id && typeof locatorDb.updateById === 'function') {
+        await locatorDb.updateById(resource, id, payload);
+        return;
+    }
+    const iri = resolveRecordIri(target);
+    if (iri) {
+        assertIriBelongsToCurrentPod(db, iri, 'update');
+    }
+    if (iri && typeof locatorDb.updateByIri === 'function') {
+        await locatorDb.updateByIri(resource, iri, payload);
+        return;
+    }
+    throw new Error('Cannot update exact record without updateById/updateByIri support.');
+}
+export async function deleteExactRecord(db, resource, target) {
+    const locatorDb = db;
+    assertCurrentPodBaseUrl(db, 'delete');
+    const id = resolveRecordId(target);
+    if (id && typeof locatorDb.deleteById === 'function') {
+        await locatorDb.deleteById(resource, id);
+        return;
+    }
+    const iri = resolveRecordIri(target);
+    if (iri) {
+        assertIriBelongsToCurrentPod(db, iri, 'delete');
+    }
+    if (iri && typeof locatorDb.deleteByIri === 'function') {
+        await locatorDb.deleteByIri(resource, iri);
+        return;
+    }
+    throw new Error('Cannot delete exact record without deleteById/deleteByIri support.');
+}
+function resolveRecordIri(target) {
+    if (typeof target === 'string') {
+        return ABSOLUTE_IRI.test(target) ? target : null;
+    }
+    if (!target)
+        return null;
+    for (const key of ['@id', 'uri', 'subject', 'source']) {
+        const value = target[key];
+        if (typeof value === 'string' && ABSOLUTE_IRI.test(value)) {
+            return value;
+        }
+    }
+    return null;
+}
+function resolveRecordId(target) {
+    if (typeof target === 'string') {
+        return ABSOLUTE_IRI.test(target)
+            ? null
+            : asBaseRelativeResourceId(target, 'record target');
+    }
+    if (!target)
+        return null;
+    return requireRowResourceId(target, 'record target');
+}
+function sanitizeUpdatePayload(updates) {
+    const payload = {};
+    for (const [key, value] of Object.entries(updates)) {
+        if (!INTERNAL_FIELDS.has(key) && value !== undefined) {
+            payload[key] = value;
+        }
+    }
+    return payload;
+}

package/vendor/stores/dist/index.d.ts

@@ -0,0 +1 @@
+export * from './login';

package/vendor/stores/dist/index.js

@@ -0,0 +1 @@
+export * from './login.js';

package/vendor/stores/dist/login.d.ts

@@ -0,0 +1,51 @@
+/**
+ * 登录状态机
+ *
+ * restoring → idle → connecting → authenticated
+ */
+export type LoginState = 'restoring' | 'idle' | 'connecting' | 'authenticated';
+export interface StoredAccount {
+    displayName: string;
+    avatarUrl?: string;
+    issuerUrl: string;
+    issuerLabel?: string;
+    storageProviderUrl?: string;
+    storageProviderLabel?: string;
+    webId?: string;
+}
+export interface ProviderOption {
+    id: string;
+    url: string;
+    label: string;
+    logoUrl?: string;
+    isDefault?: boolean;
+}
+export declare function getRememberedAccount(): StoredAccount | null;
+export interface LoginStore {
+    state: LoginState;
+    error: string | null;
+    storedAccount: StoredAccount | null;
+    customProviders: ProviderOption[];
+    setState: (state: LoginState) => void;
+    setError: (error: string | null) => void;
+    setStoredAccount: (account: StoredAccount | null) => void;
+    addCustomProvider: (provider: ProviderOption) => void;
+    removeCustomProvider: (url: string) => void;
+    loginSuccess: (account: StoredAccount) => void;
+    reset: () => void;
+}
+export declare const useLoginStore: import("zustand").UseBoundStore<Omit<import("zustand").StoreApi<LoginStore>, "setState" | "persist"> & {
+    setState(partial: LoginStore | Partial<LoginStore> | ((state: LoginStore) => LoginStore | Partial<LoginStore>), replace?: false | undefined): unknown;
+    setState(state: LoginStore | ((state: LoginStore) => LoginStore), replace: true): unknown;
+    persist: {
+        setOptions: (options: Partial<import("zustand/middleware").PersistOptions<LoginStore, unknown, unknown>>) => void;
+        clearStorage: () => void;
+        rehydrate: () => Promise<void> | void;
+        hasHydrated: () => boolean;
+        onHydrate: (fn: (state: LoginStore) => void) => () => void;
+        onFinishHydration: (fn: (state: LoginStore) => void) => () => void;
+        getOptions: () => Partial<import("zustand/middleware").PersistOptions<LoginStore, unknown, unknown>>;
+    };
+}>;
+export declare const DEFAULT_PROVIDERS: ProviderOption[];
+export declare function getAllProviders(customProviders: ProviderOption[]): ProviderOption[];

package/vendor/stores/dist/login.js

@@ -0,0 +1,195 @@
+import { create } from 'zustand';
+import { persist, createJSONStorage } from 'zustand/middleware';
+const REMEMBERED_ACCOUNT_KEY = 'linx-remembered-account';
+const LINX_CLOUD_IDENTITY_ORIGIN = 'https://id.undefineds.co';
+function getBrowserStorage() {
+    if (typeof window === 'undefined')
+        return null;
+    return window.localStorage ?? null;
+}
+function persistRememberedAccount(account) {
+    const storage = getBrowserStorage();
+    if (!storage)
+        return;
+    if (!account) {
+        storage.removeItem(REMEMBERED_ACCOUNT_KEY);
+        return;
+    }
+    storage.setItem(REMEMBERED_ACCOUNT_KEY, JSON.stringify(account));
+}
+export function getRememberedAccount() {
+    const storage = getBrowserStorage();
+    if (!storage)
+        return null;
+    const raw = storage.getItem(REMEMBERED_ACCOUNT_KEY);
+    if (!raw)
+        return null;
+    try {
+        const parsed = JSON.parse(raw);
+        const storageProviderLabel = resolveStorageProviderLabel(parsed);
+        const issuerUrl = resolveStoredAccountIssuerUrl(parsed, storageProviderLabel);
+        if (typeof parsed.displayName !== 'string' || !issuerUrl) {
+            return null;
+        }
+        return {
+            displayName: parsed.displayName,
+            avatarUrl: typeof parsed.avatarUrl === 'string' ? parsed.avatarUrl : undefined,
+            issuerUrl,
+            issuerLabel: typeof parsed.issuerLabel === 'string' ? parsed.issuerLabel : undefined,
+            storageProviderUrl: typeof parsed.storageProviderUrl === 'string'
+                ? parsed.storageProviderUrl
+                : normalizeStoredUrl(parsed.providerUrl) ?? undefined,
+            storageProviderLabel,
+            webId: typeof parsed.webId === 'string' ? parsed.webId : undefined,
+        };
+    }
+    catch {
+        storage.removeItem(REMEMBERED_ACCOUNT_KEY);
+        return null;
+    }
+}
+function migrateStoredAccount(value) {
+    if (!value || typeof value !== 'object')
+        return null;
+    const parsed = value;
+    const storageProviderLabel = resolveStorageProviderLabel(parsed);
+    const issuerUrl = resolveStoredAccountIssuerUrl(parsed, storageProviderLabel);
+    const storageProviderUrl = normalizeStoredUrl(parsed.storageProviderUrl)
+        ?? normalizeStoredUrl(parsed.providerUrl);
+    if (typeof parsed.displayName !== 'string' || !issuerUrl) {
+        return null;
+    }
+    return {
+        displayName: parsed.displayName,
+        avatarUrl: typeof parsed.avatarUrl === 'string' ? parsed.avatarUrl : undefined,
+        issuerUrl,
+        issuerLabel: typeof parsed.issuerLabel === 'string' ? parsed.issuerLabel : undefined,
+        storageProviderUrl: storageProviderUrl ?? undefined,
+        storageProviderLabel,
+        webId: typeof parsed.webId === 'string' ? parsed.webId : undefined,
+    };
+}
+function resolveStoredAccountIssuerUrl(parsed, storageProviderLabel) {
+    const explicitIssuerUrl = normalizeStoredUrl(parsed.issuerUrl);
+    if (explicitIssuerUrl) {
+        return explicitIssuerUrl;
+    }
+    if (isLegacyCloudBackedLocalAccount(parsed, storageProviderLabel)) {
+        return LINX_CLOUD_IDENTITY_ORIGIN;
+    }
+    return normalizeStoredUrl(parsed.providerUrl);
+}
+function resolveStorageProviderLabel(parsed) {
+    if (typeof parsed.storageProviderLabel === 'string') {
+        return parsed.storageProviderLabel;
+    }
+    if (typeof parsed.providerLabel === 'string') {
+        return parsed.providerLabel;
+    }
+    return undefined;
+}
+function isLegacyCloudBackedLocalAccount(parsed, storageProviderLabel) {
+    return storageProviderLabel?.trim().toLowerCase() === 'local'
+        && typeof parsed.webId === 'string'
+        && normalizeStoredUrl(parsed.webId)?.startsWith(`${LINX_CLOUD_IDENTITY_ORIGIN}/`) === true;
+}
+// ============================================================================
+// Store 实现
+// ============================================================================
+export const useLoginStore = create()(persist((set) => ({
+    // 初始状态
+    state: 'restoring',
+    error: null,
+    storedAccount: null,
+    customProviders: [],
+    // 基础 Actions
+    setState: (state) => set((current) => current.state === state ? current : { state }),
+    setError: (error) => set((current) => current.error === error ? current : { error }),
+    setStoredAccount: (account) => set((current) => {
+        if (current.storedAccount === account)
+            return current;
+        persistRememberedAccount(account);
+        return { storedAccount: account };
+    }),
+    addCustomProvider: (provider) => set((s) => ({
+        customProviders: [
+            provider,
+            ...s.customProviders.filter(p => p.url !== provider.url)
+        ].slice(0, 10)
+    })),
+    removeCustomProvider: (url) => set((s) => ({
+        customProviders: s.customProviders.filter(p => p.url !== url)
+    })),
+    // 复合 Actions
+    loginSuccess: (account) => set(() => {
+        persistRememberedAccount(account);
+        return {
+            state: 'authenticated',
+            error: null,
+            storedAccount: account,
+        };
+    }),
+    reset: () => set((current) => {
+        persistRememberedAccount(current.storedAccount);
+        return {
+            state: 'idle',
+            error: null,
+        };
+    }),
+}), {
+    name: 'linx-login',
+    version: 1,
+    migrate: (persistedState) => {
+        const state = persistedState;
+        return {
+            storedAccount: migrateStoredAccount(state.storedAccount),
+            customProviders: Array.isArray(state.customProviders) ? state.customProviders : [],
+        };
+    },
+    storage: createJSONStorage(() => {
+        if (typeof window !== 'undefined' && window.localStorage) {
+            return window.localStorage;
+        }
+        // SSR fallback
+        const memory = {};
+        return {
+            getItem: (key) => memory[key] ?? null,
+            setItem: (key, value) => { memory[key] = value; },
+            removeItem: (key) => { delete memory[key]; },
+        };
+    }),
+    // 只持久化这些字段
+    partialize: (state) => ({
+        storedAccount: state.storedAccount,
+        customProviders: state.customProviders,
+    }),
+}));
+// ============================================================================
+// 默认 Providers
+// ============================================================================
+export const DEFAULT_PROVIDERS = [
+    {
+        id: 'linx-cloud',
+        url: 'https://id.undefineds.co',
+        label: 'Cloud',
+        logoUrl: '/linx-logo.png',
+        isDefault: true,
+    },
+];
+// ============================================================================
+// 辅助函数
+// ============================================================================
+export function getAllProviders(customProviders) {
+    const map = new Map();
+    // 先添加默认的
+    DEFAULT_PROVIDERS.forEach(p => map.set(p.url, p));
+    // 再添加自定义的（会覆盖同 URL 的默认项）
+    customProviders.forEach(p => map.set(p.url, { ...p, isDefault: false }));
+    return Array.from(map.values());
+}
+function normalizeStoredUrl(url) {
+    if (typeof url !== 'string')
+        return null;
+    const trimmed = url.trim();
+    return trimmed.length > 0 ? trimmed : null;
+}

package/vendor/stores/dist/pod-collection.d.ts

@@ -0,0 +1,28 @@
+import { QueryClient } from '@tanstack/react-query';
+import type { SolidDatabase } from '@undefineds.co/models';
+import type { PodResource as PodResourceSchema } from '@undefineds.co/drizzle-solid';
+interface PodCollectionOptions<TResource, TData> {
+    resource: TResource;
+    queryKey: string[];
+    queryClient: QueryClient;
+    getDb: () => SolidDatabase<any> | null;
+    columns?: (keyof TData)[];
+    orderBy?: {
+        column: string;
+        direction?: 'asc' | 'desc';
+    };
+    getKey?: (item: TData) => string;
+    seed?: TData[] | (() => TData[]);
+}
+/**
+ * Creates a TanStack DB Collection synchronized with a Solid Pod resource.
+ * Includes support for real-time subscriptions via db.subscribe().
+ */
+export declare function createPodCollection<TResource extends PodResourceSchema<any>, TData extends {
+    id?: string;
+}, _TInsert = any>(options: PodCollectionOptions<TResource, TData>): import("@tanstack/db").Collection<TData, string, import("@tanstack/db").UtilsRecord, never, TData> & import("@tanstack/db").NonSingleResult & {
+    insert: (item: TData) => import("@tanstack/db").Transaction<Record<string, unknown>>;
+    subscribeToPod: (db: SolidDatabase<any>) => Promise<() => void>;
+    fetch: () => Promise<TData[]>;
+};
+export {};