@mdfriday/foundry 26.3.1 → 26.3.3

package/dist/internal/domain/workspace/entity/project.d.ts

@@ -60,6 +60,11 @@ export declare class Project {
     getStaticLink(): {
         sourcePath: string;
     } | null;
+    getFileLink(): {
+        sourcePath: string;
+        targetPath: string;
+        isSymlink: boolean;
+    } | null;
     setContentLinks(links: Array<{
         sourcePath: string;
         languageCode: string;

package/dist/internal/interfaces/obsidian/auth.d.ts

@@ -0,0 +1,26 @@
+import { HttpClient } from '@internal/domain/publish/repository/http-client';
+export interface ObsidianAuthStatus {
+    isAuthenticated: boolean;
+    email?: string;
+    serverUrl: string;
+    token?: string;
+}
+export interface ObsidianServerConfig {
+    apiUrl: string;
+    websiteUrl?: string;
+}
+export interface ObsidianAuthResult<T = void> {
+    success: boolean;
+    message: string;
+    data?: T;
+    error?: string;
+}
+export declare class ObsidianAuthService {
+    private httpClient;
+    constructor(httpClient?: HttpClient);
+    getStatus(): Promise<ObsidianAuthResult<ObsidianAuthStatus>>;
+    getConfig(): Promise<ObsidianAuthResult<ObsidianServerConfig>>;
+    updateConfig(config: ObsidianServerConfig): Promise<ObsidianAuthResult<ObsidianServerConfig>>;
+    private getIdentityService;
+}
+export declare function createObsidianAuthService(httpClient?: HttpClient): ObsidianAuthService;

package/dist/internal/interfaces/obsidian/build.d.ts

@@ -0,0 +1,31 @@
+import { WorkspaceAppService } from '@internal/application/workspace';
+export interface ObsidianBuildOptions {
+    workspacePath: string;
+    projectNameOrPath: string;
+    destination?: string;
+    modulesDir?: string;
+    contentDirs?: string[];
+    clean?: boolean;
+    parallel?: boolean;
+    snapshot?: boolean;
+    snapshotName?: string;
+}
+export interface ObsidianBuildResult {
+    success: boolean;
+    message?: string;
+    data?: {
+        projectName: string;
+        duration: number;
+        outputDir: string;
+        contentDirs: string[];
+        snapshot?: string;
+    };
+    error?: string;
+}
+export declare class ObsidianBuildService {
+    private workspaceAppService;
+    constructor(workspaceAppService: WorkspaceAppService);
+    buildProject(options: ObsidianBuildOptions): Promise<ObsidianBuildResult>;
+    private cleanOutputDir;
+}
+export declare function createObsidianBuildService(): ObsidianBuildService;

package/dist/internal/interfaces/obsidian/config.d.ts

@@ -0,0 +1,47 @@
+import { WorkspaceAppService } from '@internal/application/workspace';
+export interface ObsidianConfigResult<T = any> {
+    success: boolean;
+    message?: string;
+    data?: T;
+    error?: string;
+}
+export interface ConfigGetResult {
+    key: string;
+    value: any;
+    project?: string;
+}
+export interface ConfigListResult {
+    config: Record<string, any>;
+    scope: 'global' | 'project';
+    project?: string;
+}
+export declare class ObsidianGlobalConfigService {
+    private workspaceAppService;
+    constructor(workspaceAppService: WorkspaceAppService);
+    get(workspacePath: string, key: string): Promise<ObsidianConfigResult<ConfigGetResult>>;
+    set(workspacePath: string, key: string, value: any): Promise<ObsidianConfigResult<ConfigGetResult>>;
+    list(workspacePath: string): Promise<ObsidianConfigResult<ConfigListResult>>;
+    unset(workspacePath: string, key: string): Promise<ObsidianConfigResult<{
+        key: string;
+    }>>;
+    getConfigPath(workspacePath: string): Promise<ObsidianConfigResult<{
+        path: string;
+    }>>;
+}
+export declare class ObsidianProjectConfigService {
+    private workspaceAppService;
+    constructor(workspaceAppService: WorkspaceAppService);
+    get(workspacePath: string, projectName: string, key: string): Promise<ObsidianConfigResult<ConfigGetResult>>;
+    set(workspacePath: string, projectName: string, key: string, value: any): Promise<ObsidianConfigResult<ConfigGetResult>>;
+    list(workspacePath: string, projectName: string): Promise<ObsidianConfigResult<ConfigListResult>>;
+    unset(workspacePath: string, projectName: string, key: string): Promise<ObsidianConfigResult<{
+        key: string;
+        project: string;
+    }>>;
+    getConfigPath(workspacePath: string, projectName: string): Promise<ObsidianConfigResult<{
+        path: string;
+        project: string;
+    }>>;
+}
+export declare function createObsidianGlobalConfigService(): ObsidianGlobalConfigService;
+export declare function createObsidianProjectConfigService(): ObsidianProjectConfigService;

package/dist/internal/interfaces/obsidian/domain.d.ts

@@ -0,0 +1,59 @@
+import { HttpClient } from '@internal/domain/publish/repository/http-client';
+export interface ObsidianDomainInfo {
+    subdomain: string;
+    fullDomain: string;
+    customDomain?: string;
+    folder: string;
+    createdAt: string;
+}
+export interface ObsidianSubdomainCheckResult {
+    available: boolean;
+    message?: string;
+}
+export interface ObsidianSubdomainUpdateResult {
+    oldSubdomain: string;
+    newSubdomain: string;
+    fullDomain: string;
+    message: string;
+}
+export interface ObsidianCustomDomainCheckResult {
+    ready: boolean;
+    dnsValid: boolean;
+    resolvedIps?: string[];
+    message: string;
+}
+export interface ObsidianCustomDomainAddResult {
+    domain: string;
+    status: string;
+    message: string;
+}
+export interface ObsidianHttpsCertificate {
+    issuer?: string;
+    validFrom?: string;
+    validTo?: string;
+}
+export interface ObsidianHttpsStatusResult {
+    tlsReady: boolean;
+    dnsValid: boolean;
+    status: string;
+    message: string;
+    certificate?: ObsidianHttpsCertificate;
+}
+export interface ObsidianDomainResult<T = void> {
+    success: boolean;
+    message: string;
+    data?: T;
+    error?: string;
+}
+export declare class ObsidianDomainService {
+    private httpClient;
+    constructor(httpClient?: HttpClient);
+    getDomainInfo(): Promise<ObsidianDomainResult<ObsidianDomainInfo>>;
+    checkSubdomain(subdomain: string): Promise<ObsidianDomainResult<ObsidianSubdomainCheckResult>>;
+    updateSubdomain(newSubdomain: string): Promise<ObsidianDomainResult<ObsidianSubdomainUpdateResult>>;
+    checkCustomDomain(domain: string): Promise<ObsidianDomainResult<ObsidianCustomDomainCheckResult>>;
+    addCustomDomain(domain: string): Promise<ObsidianDomainResult<ObsidianCustomDomainAddResult>>;
+    checkHttpsStatus(domain: string): Promise<ObsidianDomainResult<ObsidianHttpsStatusResult>>;
+    private getIdentityService;
+}
+export declare function createObsidianDomainService(httpClient?: HttpClient): ObsidianDomainService;

package/dist/internal/interfaces/obsidian/index.d.ts

@@ -1,2 +1,11 @@
 export { ObsidianWorkspaceService, createObsidianWorkspaceService, ObsidianWorkspaceInitOptions, ObsidianWorkspaceInfo, ObsidianWorkspaceResult, } from './workspace';
+export { ObsidianProjectService, createObsidianProjectService, ObsidianProjectCreateOptions, ObsidianProjectInfo, ObsidianProjectResult, } from './project';
+export { ObsidianBuildService, createObsidianBuildService, ObsidianBuildOptions, ObsidianBuildResult, } from './build';
+export { ObsidianGlobalConfigService, ObsidianProjectConfigService, createObsidianGlobalConfigService, createObsidianProjectConfigService, ObsidianConfigResult, ConfigGetResult, ConfigListResult, } from './config';
+export { ObsidianPublishService, createObsidianPublishService, ObsidianPublishMethod, ObsidianPublishOptions, ObsidianPublishProgress, ObsidianPublishResult, ObsidianTestConnectionResult, } from './publish';
+export { ObsidianServeService, createObsidianServeService, ObsidianServeOptions, ObsidianServeResult, ObsidianServeProgress, } from './serve';
+export { ObsidianLicenseService, createObsidianLicenseService, ObsidianLicenseInfo, ObsidianLicenseUsage, ObsidianLicenseResult, } from './license';
+export { ObsidianAuthService, createObsidianAuthService, ObsidianAuthStatus, ObsidianServerConfig, ObsidianAuthResult, } from './auth';
+export { ObsidianDomainService, createObsidianDomainService, ObsidianDomainInfo, ObsidianSubdomainCheckResult, ObsidianSubdomainUpdateResult, ObsidianCustomDomainCheckResult, ObsidianCustomDomainAddResult, ObsidianHttpsCertificate, ObsidianHttpsStatusResult, ObsidianDomainResult, } from './domain';
 export { createWorkspaceAppService, createWorkspaceFactory, } from './container';
+export type { HttpClient, HttpResponse } from '@internal/domain/publish/repository/http-client';

package/dist/internal/interfaces/obsidian/license.d.ts

@@ -0,0 +1,76 @@
+import { WorkspaceAppService } from '@internal/application/workspace';
+import { HttpClient } from '@internal/domain/publish/repository/http-client';
+export interface ObsidianLicenseInfo {
+    key: string;
+    plan: string;
+    isExpired: boolean;
+    expires: string;
+    daysRemaining: number;
+    isTrial: boolean;
+    features: {
+        maxDevices: number;
+        maxIps: number;
+        syncEnabled: boolean;
+        syncQuota: number;
+        publishEnabled: boolean;
+        maxSites: number;
+        maxStorage: number;
+        customDomain: boolean;
+        customSubDomain: boolean;
+    };
+}
+export interface ObsidianLicenseUsage {
+    licenseKey: string;
+    plan: string;
+    devices: {
+        count: number;
+        max: number;
+        list: Array<{
+            id: string;
+            name: string;
+            type: string;
+            status: string;
+            lastSeenAt: string;
+        }>;
+    };
+    ips: {
+        count: number;
+        max: number;
+        list: Array<{
+            ip: string;
+            city: string;
+            region: string;
+            country: string;
+            status: string;
+            lastSeenAt: string;
+        }>;
+    };
+    disk: {
+        syncUsage: number;
+        publishUsage: number;
+        totalUsage: number;
+        maxStorage: number;
+        unit: string;
+    };
+}
+export interface ObsidianLicenseResult<T = any> {
+    success: boolean;
+    message?: string;
+    data?: T;
+    error?: string;
+}
+export declare class ObsidianLicenseService {
+    private workspaceAppService;
+    private httpClient;
+    constructor(workspaceAppService: WorkspaceAppService, httpClient?: HttpClient);
+    requestTrial(email: string): Promise<ObsidianLicenseResult<ObsidianLicenseInfo>>;
+    loginWithLicense(licenseKey: string): Promise<ObsidianLicenseResult<ObsidianLicenseInfo>>;
+    activateLicense(licenseKey: string): Promise<ObsidianLicenseResult<ObsidianLicenseInfo>>;
+    getLicenseInfo(): Promise<ObsidianLicenseResult<ObsidianLicenseInfo>>;
+    getLicenseUsage(): Promise<ObsidianLicenseResult<ObsidianLicenseUsage>>;
+    resetUsage(force: boolean): Promise<ObsidianLicenseResult<any>>;
+    hasActiveLicense(): Promise<boolean>;
+    private getIdentityService;
+    private buildLicenseInfo;
+}
+export declare function createObsidianLicenseService(httpClient?: HttpClient): ObsidianLicenseService;

package/dist/internal/interfaces/obsidian/project.d.ts

@@ -0,0 +1,51 @@
+import { WorkspaceAppService } from '@internal/application/workspace';
+export interface ObsidianProjectCreateOptions {
+    name: string;
+    workspacePath: string;
+    theme?: string;
+    language?: string;
+    sourceFile?: string;
+    sourceFolder?: string;
+    createSampleContent?: boolean;
+}
+export interface ObsidianProjectInfo {
+    id: string;
+    name: string;
+    path: string;
+    createdAt: string;
+    updatedAt: string;
+    theme?: string;
+    language?: string;
+    fileLink?: {
+        sourcePath: string;
+        targetPath: string;
+        isSymlink: boolean;
+    };
+    contentLinks?: Array<{
+        sourcePath: string;
+        languageCode: string;
+        weight: number;
+    }>;
+    staticLink?: {
+        sourcePath: string;
+    };
+    languages?: string[];
+}
+export interface ObsidianProjectResult<T = any> {
+    success: boolean;
+    message?: string;
+    data?: T;
+    error?: string;
+}
+export declare class ObsidianProjectService {
+    private workspaceAppService;
+    constructor(workspaceAppService: WorkspaceAppService);
+    createProject(options: ObsidianProjectCreateOptions): Promise<ObsidianProjectResult<ObsidianProjectInfo>>;
+    private createProjectFromFile;
+    private createProjectFromFolder;
+    private createEmptyProject;
+    private buildProjectInfo;
+    listProjects(workspacePath: string): Promise<ObsidianProjectResult<ObsidianProjectInfo[]>>;
+    getProjectInfo(workspacePath: string, projectName: string): Promise<ObsidianProjectResult<ObsidianProjectInfo>>;
+}
+export declare function createObsidianProjectService(): ObsidianProjectService;

package/dist/internal/interfaces/obsidian/publish.d.ts

@@ -0,0 +1,43 @@
+import { PublishAppService } from '@internal/application/publish';
+import { WorkspaceAppService } from '@internal/application/workspace';
+import { HttpClient } from '@internal/domain/publish/repository/http-client';
+export type ObsidianPublishMethod = 'ftp' | 'netlify' | 'mdfriday';
+export interface ObsidianPublishOptions {
+    workspacePath: string;
+    projectName: string;
+    method: ObsidianPublishMethod;
+    force?: boolean;
+    config?: any;
+}
+export interface ObsidianPublishProgress {
+    phase: 'scanning' | 'uploading' | 'deploying' | 'complete';
+    percentage: number;
+    message: string;
+    currentFile?: string;
+    filesCompleted?: number;
+    filesTotal?: number;
+    bytesTransferred?: number;
+}
+export interface ObsidianPublishResult {
+    success: boolean;
+    message?: string;
+    data?: {
+        url?: string;
+        filesUploaded: number;
+        bytesTransferred: number;
+        duration: number;
+    };
+    error?: string;
+}
+export interface ObsidianTestConnectionResult {
+    success: boolean;
+    error?: string;
+}
+export declare class ObsidianPublishService {
+    private publishAppService;
+    private workspaceAppService;
+    constructor(publishAppService: PublishAppService, workspaceAppService: WorkspaceAppService);
+    publish(options: ObsidianPublishOptions, onProgress?: (progress: ObsidianPublishProgress) => void): Promise<ObsidianPublishResult>;
+    testConnection(workspacePath: string, projectName: string, method: ObsidianPublishMethod): Promise<ObsidianTestConnectionResult>;
+}
+export declare function createObsidianPublishService(httpClient: HttpClient): ObsidianPublishService;

package/dist/internal/interfaces/obsidian/serve.d.ts

@@ -0,0 +1,47 @@
+import { WorkspaceAppService } from '@internal/application/workspace';
+import { PublishAppService } from '@internal/application/publish';
+import { HttpClient } from '@internal/domain/publish/repository/http-client';
+export interface ObsidianServeOptions {
+    workspacePath: string;
+    projectName: string;
+    port?: number;
+    host?: string;
+    livereloadPort?: number;
+    livereload?: boolean;
+    publish?: 'ftp' | 'netlify' | 'mdfriday';
+    publishDelay?: number;
+    publishConfig?: {
+        type?: string;
+        licenseKey?: string;
+    };
+}
+export interface ObsidianServeResult {
+    success: boolean;
+    message?: string;
+    data?: {
+        url: string;
+        port: number;
+        host: string;
+        livereloadPort?: number;
+        autoPublish?: string;
+    };
+    error?: string;
+}
+export interface ObsidianServeProgress {
+    phase: 'initializing' | 'building' | 'watching' | 'publishing' | 'ready';
+    percentage: number;
+    message: string;
+    currentFile?: string;
+}
+export declare class ObsidianServeService {
+    private workspaceAppService;
+    private publishAppService;
+    private coordinator?;
+    private publishTimer?;
+    constructor(workspaceAppService: WorkspaceAppService, publishAppService?: PublishAppService);
+    startServer(options: ObsidianServeOptions, onProgress?: (progress: ObsidianServeProgress) => void): Promise<ObsidianServeResult>;
+    stopServer(): Promise<boolean>;
+    isRunning(): boolean;
+    private autoPublish;
+}
+export declare function createObsidianServeService(httpClient?: HttpClient): ObsidianServeService;

package/dist/worker/pool-manager.js

@@ -116,6 +116,7 @@ var init_logger = __esm({
           entry.caller = caller;
         }
         const output = this.config.jsonFormat ? JSON.stringify(entry) : this.formatPlainText(entry);
+        console.log(output);
         if (level === "error" /* ERROR */ || level === "fatal" /* FATAL */) {
           process.stderr.write(output + "\n");
         } else {

package/dist/worker/worker-node.js

@@ -116,6 +116,7 @@ var init_logger = __esm({
           entry.caller = caller;
         }
         const output = this.config.jsonFormat ? JSON.stringify(entry) : this.formatPlainText(entry);
+        console.log(output);
         if (level === "error" /* ERROR */ || level === "fatal" /* FATAL */) {
           process.stderr.write(output + "\n");
         } else {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mdfriday/foundry",
-  "version": "26.3.1",
+  "version": "26.3.3",
   "description": "The core engine of MDFriday. Convert Markdown and shortcodes into fully themed static sites – Hugo-style, powered by TypeScript.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",