@synopackageland/cli 0.1.0

package/dist/host/types.d.ts

@@ -0,0 +1,67 @@
+export type AttestationKind = "local" | "app-package" | "none";
+export interface DeployIdentity {
+    packageId: string;
+    displayname: string;
+    developmentInstance: boolean;
+}
+export interface AttestationIssueResult {
+    kind: "local";
+    attestationDigest: string;
+}
+export interface HostAttestationInfo {
+    packageIdentity: string;
+    attestationKind: AttestationKind;
+    developmentInstance: boolean;
+    openUrl?: string;
+    readiness?: string;
+    projectName?: string;
+}
+export interface HostInstallRecord {
+    packageId: string;
+    version?: string;
+    source?: "package-center" | "local-spk";
+    extraValues?: Record<string, string>;
+}
+export interface NasHost {
+    readonly dsmOrigin: string;
+    readonly installationId: string;
+    requestAttestation(input: {
+        packageIdentity: string;
+        contractDigest: string;
+        bundleDigest: string;
+        capabilities: string[];
+        allowCuratedDowngrade?: boolean;
+    }): Promise<AttestationIssueResult>;
+    installFromCatalog(input: {
+        packageId: string;
+        version?: string;
+        extraValues?: Record<string, string>;
+    }): Promise<void>;
+    installFromLocalSpk?(input: {
+        packageId: string;
+        version: string;
+        spkPath: string;
+        extraValues?: Record<string, string>;
+    }): Promise<void>;
+    resolveSharePath?(logicalName: string): Promise<string | undefined>;
+    getInstalledProjectEnv?(packageIdentity: string): Promise<Record<string, string> | undefined>;
+    ensurePackageSource?(origin: string): Promise<void>;
+    getInstalledPackageVersion?(packageIdentity: string): Promise<string | undefined>;
+    getAttestationInfo(packageIdentity: string): Promise<HostAttestationInfo>;
+    isPackageInstalled(packageIdentity: string): Promise<boolean>;
+    fetchContainerLogs(packageIdentity: string): Promise<string[]>;
+    smokeRequireLogin(input: {
+        packageIdentity: string;
+        cookieHeader: string;
+    }): Promise<{
+        ok: boolean;
+        username?: string;
+    }>;
+    markCurated?(packageIdentity: string): void;
+}
+export interface HostCredentials {
+    dsmOrigin: string;
+    username: string;
+    password: string;
+    cookieHeader?: string;
+}

package/dist/host/types.js

@@ -0,0 +1 @@
+export {};

package/dist/index.d.ts

@@ -0,0 +1,19 @@
+export { runCli } from "./cli.js";
+export { validateProject, findProjectRoot } from "./validate.js";
+export type { AnalyzerProfile } from "./validate.js";
+export { inspectProject, formatInspectReport } from "./inspect.js";
+export { initFromTemplate, isTemplateName } from "./init.js";
+export { runDev } from "./dev.js";
+export { testProject } from "./test-command.js";
+export { buildSpk } from "./build-spk/generator.js";
+export { publishProject, resolveCommunityAppsRoot } from "./publish/publish.js";
+export { communityAppsGitHubRepo, communityAppsGitHubUrl, DEFAULT_GITHUB_OWNER, } from "./publish/github-repo.js";
+export { InMemoryBuildLedger } from "./publish/build-ledger.js";
+export type { BuildLedger } from "./publish/build-ledger.js";
+export { createCuratedAttestationSignerFromEnv, isPublicOciDigest, releaseCurated, runCuratedRelease, runCuratedReleaseCli, digestReleaseBundle, validateCuratedCompose, } from "./publish/curated-release.js";
+export type { CuratedAttestationSignInput, CuratedAttestationSigner, CuratedComposeGateResult, CuratedReleaseSignInput, CuratedReleaseOptions, CuratedReleaseResult, } from "./publish/curated-release.js";
+export { canonicalAppPackageClaims, canonicalCuratedReleaseClaims, digestAppPackageClaims, digestCuratedReleaseClaims, normalizeCapabilities, assertPackageVersionBinding, signCuratedAppPackageAttestationToken, signCuratedReleaseAttestationToken, } from "./attestation/app-package.js";
+export type { AppPackageAttestationClaims, AppPackageSigningKey, CuratedAppPackageAttestationInput, CuratedReleaseAttestationClaims, CuratedReleaseAttestationInput, } from "./attestation/app-package.js";
+export { startMockBroker, FAKE_USER } from "./mock-broker/server.js";
+export { RecordingComposeRunner } from "./compose/runner.js";
+export type { ValidationError, ValidationResult } from "./types.js";

package/dist/index.js

@@ -0,0 +1,14 @@
+export { runCli } from "./cli.js";
+export { validateProject, findProjectRoot } from "./validate.js";
+export { inspectProject, formatInspectReport } from "./inspect.js";
+export { initFromTemplate, isTemplateName } from "./init.js";
+export { runDev } from "./dev.js";
+export { testProject } from "./test-command.js";
+export { buildSpk } from "./build-spk/generator.js";
+export { publishProject, resolveCommunityAppsRoot } from "./publish/publish.js";
+export { communityAppsGitHubRepo, communityAppsGitHubUrl, DEFAULT_GITHUB_OWNER, } from "./publish/github-repo.js";
+export { InMemoryBuildLedger } from "./publish/build-ledger.js";
+export { createCuratedAttestationSignerFromEnv, isPublicOciDigest, releaseCurated, runCuratedRelease, runCuratedReleaseCli, digestReleaseBundle, validateCuratedCompose, } from "./publish/curated-release.js";
+export { canonicalAppPackageClaims, canonicalCuratedReleaseClaims, digestAppPackageClaims, digestCuratedReleaseClaims, normalizeCapabilities, assertPackageVersionBinding, signCuratedAppPackageAttestationToken, signCuratedReleaseAttestationToken, } from "./attestation/app-package.js";
+export { startMockBroker, FAKE_USER } from "./mock-broker/server.js";
+export { RecordingComposeRunner } from "./compose/runner.js";

package/dist/info.d.ts

@@ -0,0 +1,17 @@
+import type { ProjectRoot } from "./discovery.js";
+import type { NasHost } from "./host/types.js";
+export interface ProjectInfoOptions {
+    project: ProjectRoot;
+    host: NasHost;
+    dev?: boolean;
+}
+export declare function projectInfo(options: ProjectInfoOptions): Promise<ProjectInfoResult>;
+export interface ProjectInfoResult {
+    packageIdentity: string;
+    attestationKind: "local" | "app-package" | "none";
+    developmentInstance: boolean;
+    openUrl?: string;
+    readiness?: string;
+    installed: boolean;
+}
+export declare function formatProjectInfo(info: ProjectInfoResult): string;

package/dist/info.js

@@ -0,0 +1,34 @@
+import { loadContract } from "./contract/load.js";
+import { appOriginFromContract } from "./host/open-url.js";
+import { resolveDeployIdentity } from "./deploy/identity.js";
+export async function projectInfo(options) {
+    const identity = resolveDeployIdentity(options.project, { dev: options.dev });
+    const remote = await options.host.getAttestationInfo(identity.packageId);
+    const installed = await options.host.isPackageInstalled(identity.packageId);
+    const contract = loadContract(options.project.contractPath).contract;
+    return {
+        packageIdentity: identity.packageId,
+        attestationKind: remote.attestationKind,
+        developmentInstance: identity.developmentInstance,
+        openUrl: remote.openUrl ?? appOriginFromContract(options.host.dsmOrigin, contract),
+        readiness: remote.readiness ?? (installed ? "UNKNOWN" : "NOT_INSTALLED"),
+        installed,
+    };
+}
+export function formatProjectInfo(info) {
+    const attestationLabel = info.attestationKind === "app-package"
+        ? "Curated（App Package Attestation）"
+        : info.attestationKind === "local"
+            ? "Local（Local Attestation）"
+            : "無";
+    return [
+        `Package Identity：${info.packageIdentity}`,
+        `Attestation：${attestationLabel}`,
+        `開發用 Instance：${info.developmentInstance ? "是" : "否"}`,
+        `已安裝：${info.installed ? "是" : "否"}`,
+        info.openUrl ? `Open URL：${info.openUrl}` : "Open URL：（未設定）",
+        info.readiness ? `Readiness：${info.readiness}` : "",
+    ]
+        .filter(Boolean)
+        .join("\n");
+}

package/dist/init.d.ts

@@ -0,0 +1,4 @@
+import type { TemplateName } from "./types.js";
+export declare function isTemplateName(value: string): value is TemplateName;
+export declare function listTemplates(): TemplateName[];
+export declare function initFromTemplate(template: TemplateName, targetDir: string): void;

package/dist/init.js

@@ -0,0 +1,31 @@
+import { mkdirSync, cpSync, existsSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+const TEMPLATE_NAMES = [
+    "hello-web",
+    "hello-web-page",
+    "hello-files",
+    "compose-import",
+];
+export function isTemplateName(value) {
+    return TEMPLATE_NAMES.includes(value);
+}
+export function listTemplates() {
+    return [...TEMPLATE_NAMES];
+}
+function templatesRoot() {
+    const moduleDir = dirname(fileURLToPath(import.meta.url));
+    const distTemplates = join(moduleDir, "templates");
+    if (existsSync(distTemplates)) {
+        return distTemplates;
+    }
+    return join(moduleDir, "..", "templates");
+}
+export function initFromTemplate(template, targetDir) {
+    const source = join(templatesRoot(), template);
+    if (!existsSync(source)) {
+        throw new Error(`找不到模板：${template}`);
+    }
+    mkdirSync(targetDir, { recursive: true });
+    cpSync(source, targetDir, { recursive: true });
+}

package/dist/inspect.d.ts

@@ -0,0 +1,13 @@
+import { type ProjectRoot } from "./discovery.js";
+export interface InspectReport {
+    services: string[];
+    publishedPorts: Array<{
+        port: number;
+        services: string[];
+    }>;
+    dataMounts: string[];
+    risks: string[];
+    webHints: string[];
+}
+export declare function inspectProject(project: ProjectRoot): InspectReport;
+export declare function formatInspectReport(report: InspectReport): string;

package/dist/inspect.js

@@ -0,0 +1,102 @@
+import { existsSync } from "node:fs";
+import { collectPublishedTcpPorts, listServiceNames, loadCompose, } from "./compose/analyze.js";
+export function inspectProject(project) {
+    const services = [];
+    const publishedPorts = [];
+    const dataMounts = [];
+    const risks = [];
+    const webHints = [];
+    if (!existsSync(project.composePath)) {
+        return {
+            services,
+            publishedPorts,
+            dataMounts,
+            risks: ["缺少 compose.yaml"],
+            webHints,
+        };
+    }
+    const parsed = loadCompose(project.composePath);
+    if (!parsed) {
+        return { services, publishedPorts, dataMounts, risks, webHints };
+    }
+    const compose = parsed.compose;
+    services.push(...listServiceNames(compose));
+    for (const [port, serviceNames] of collectPublishedTcpPorts(compose).entries()) {
+        publishedPorts.push({ port, services: serviceNames });
+    }
+    collectDataMounts(compose, dataMounts);
+    collectRisks(compose, risks);
+    if (publishedPorts.length > 0) {
+        const primary = publishedPorts[0];
+        webHints.push(`偵測到 published port ${primary.port}，可考慮在 synology-app.yaml 設定 adminport: ${primary.port}。`);
+        webHints.push("Web App 通常還需要 adminprotocol 與 adminurl。");
+        webHints.push("Launch Mode：integration.web.launch 為 dsm-window（預設，DSM 視窗）或 new-page（新分頁）。");
+    }
+    return { services, publishedPorts, dataMounts, risks, webHints };
+}
+function collectDataMounts(compose, out) {
+    if (!compose.services) {
+        return;
+    }
+    for (const [serviceName, service] of Object.entries(compose.services)) {
+        const volumes = normalizeVolumeEntries(service.volumes);
+        for (const volume of volumes) {
+            if (volume.includes("SYNOPKG_PKGVAR") || volume.includes("SYNO_APP_SECRETS_DIR")) {
+                out.push(`${serviceName}: ${volume}`);
+            }
+        }
+    }
+}
+function collectRisks(compose, out) {
+    if (!compose.services) {
+        return;
+    }
+    for (const [serviceName, service] of Object.entries(compose.services)) {
+        if (service.privileged) {
+            out.push(`${serviceName}: privileged`);
+        }
+        if (service.network_mode === "host") {
+            out.push(`${serviceName}: host network`);
+        }
+        if (Array.isArray(service.devices) && service.devices.length > 0) {
+            out.push(`${serviceName}: devices`);
+        }
+        if (Array.isArray(service.cap_add) && service.cap_add.length > 0) {
+            out.push(`${serviceName}: cap_add`);
+        }
+    }
+}
+function normalizeVolumeEntries(volumes) {
+    if (!volumes) {
+        return [];
+    }
+    const entries = Array.isArray(volumes) ? volumes : [volumes];
+    return entries
+        .map((entry) => (typeof entry === "string" ? entry : JSON.stringify(entry)))
+        .filter(Boolean);
+}
+export function formatInspectReport(report) {
+    const lines = [];
+    lines.push("Services:");
+    lines.push(report.services.length > 0 ? report.services.join(", ") : "(none)");
+    lines.push("");
+    lines.push("Published TCP ports:");
+    if (report.publishedPorts.length === 0) {
+        lines.push("(none)");
+    }
+    else {
+        for (const entry of report.publishedPorts) {
+            lines.push(`- ${entry.port} (${entry.services.join(", ")})`);
+        }
+    }
+    lines.push("");
+    lines.push("Data intents:");
+    lines.push(report.dataMounts.length > 0 ? report.dataMounts.join("\n") : "(none)");
+    lines.push("");
+    lines.push("Risk intents:");
+    lines.push(report.risks.length > 0 ? report.risks.join("\n") : "(none)");
+    lines.push("");
+    lines.push("Web entry hints:");
+    lines.push(report.webHints.length > 0 ? report.webHints.join("\n") : "(none)");
+    return lines.join("\n");
+}

package/dist/load-env.d.ts

@@ -0,0 +1 @@
+export declare function loadDotEnv(fromDir?: string): string | null;

package/dist/load-env.js

@@ -0,0 +1,31 @@
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+export function loadDotEnv(fromDir = process.cwd()) {
+    let current = resolve(fromDir);
+    while (true) {
+        const candidate = join(current, ".env");
+        if (existsSync(candidate)) {
+            for (const line of readFileSync(candidate, "utf8").split("\n")) {
+                const trimmed = line.trim();
+                if (!trimmed || trimmed.startsWith("#")) {
+                    continue;
+                }
+                const eq = trimmed.indexOf("=");
+                if (eq <= 0) {
+                    continue;
+                }
+                const key = trimmed.slice(0, eq).trim();
+                const value = trimmed.slice(eq + 1).trim();
+                if (process.env[key] === undefined) {
+                    process.env[key] = value;
+                }
+            }
+            return candidate;
+        }
+        const parent = dirname(current);
+        if (parent === current) {
+            return null;
+        }
+        current = parent;
+    }
+}

package/dist/log.d.ts

@@ -0,0 +1,13 @@
+import type { ProjectRoot } from "./discovery.js";
+import type { NasHost } from "./host/types.js";
+export interface FollowProjectLogsOptions {
+    project: ProjectRoot;
+    host: NasHost;
+    dev?: boolean;
+}
+export interface FollowProjectLogsResult {
+    ok: boolean;
+    lines: string[];
+    diagnostics?: Record<string, unknown>;
+}
+export declare function followProjectLogs(options: FollowProjectLogsOptions): Promise<FollowProjectLogsResult>;

package/dist/log.js

@@ -0,0 +1,20 @@
+import { resolveDeployIdentity } from "./deploy/identity.js";
+export async function followProjectLogs(options) {
+    const identity = resolveDeployIdentity(options.project, { dev: options.dev });
+    const installed = await options.host.isPackageInstalled(identity.packageId);
+    if (!installed) {
+        return { ok: false, lines: [], diagnostics: { code: "NOT_INSTALLED" } };
+    }
+    const lines = await options.host.fetchContainerLogs(identity.packageId);
+    const info = await options.host.getAttestationInfo(identity.packageId);
+    return {
+        ok: true,
+        lines,
+        diagnostics: {
+            packageIdentity: identity.packageId,
+            attestationKind: info.attestationKind,
+            readiness: info.readiness,
+            redacted: true,
+        },
+    };
+}

package/dist/mock-broker/bootstrap.d.ts

@@ -0,0 +1,2 @@
+import type { BrokerBootstrap } from "@synopackageland/dev-sdk/node";
+export declare function writeMockBrokerBootstrap(projectRoot: string, bootstrap: BrokerBootstrap): string;

package/dist/mock-broker/bootstrap.js

@@ -0,0 +1,8 @@
+import { mkdirSync, writeFileSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+export function writeMockBrokerBootstrap(projectRoot, bootstrap) {
+    const path = resolve(projectRoot, ".synopkgland", "mock-broker.json");
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, `${JSON.stringify(bootstrap, null, 2)}\n`, "utf8");
+    return path;
+}

package/dist/mock-broker/files.d.ts

@@ -0,0 +1,60 @@
+import { createReadStream } from "node:fs";
+export interface FileItem {
+    name: string;
+    type: "file" | "directory";
+    path: string;
+    size?: number;
+}
+export declare class FileStoreError extends Error {
+    readonly code: string;
+    readonly status: number;
+    constructor(code: string, status: number, message: string);
+}
+export interface MockFileStoreOptions {
+    filesRoot?: string;
+    recycleBinDisabled?: boolean;
+}
+export interface DownloadResult {
+    buffer?: Buffer;
+    stream?: ReturnType<typeof createReadStream>;
+    size: number;
+    totalSize: number;
+}
+export declare class MockFileStore {
+    private readonly filesRoot?;
+    private readonly recycleBinDisabled;
+    private readonly treeRoot;
+    constructor(options?: MockFileStoreOptions);
+    list(rawPath: string): FileItem[];
+    stat(rawPath: string): FileItem;
+    download(rawPath: string, range?: {
+        start: number;
+        end?: number;
+    }): DownloadResult;
+    upload(rawPath: string, body: Buffer, overwrite?: boolean): void;
+    mkdir(rawPath: string): void;
+    rename(rawPath: string, rawTo: string, overwrite?: boolean): void;
+    move(rawPath: string, rawTo: string, overwrite?: boolean): void;
+    copy(rawPath: string, rawTo: string, overwrite?: boolean): void;
+    trash(rawPath: string): void;
+    private resolveListPath;
+    private resolveOperationPath;
+    private listMemory;
+    private statMemory;
+    private downloadMemory;
+    private uploadMemory;
+    private mkdirMemory;
+    private moveMemory;
+    private copyMemory;
+    private trashMemory;
+    private listMapped;
+    private statMapped;
+    private downloadMapped;
+    private uploadMapped;
+    private mkdirMapped;
+    private moveMapped;
+    private copyMapped;
+    private trashMapped;
+}
+/** @deprecated Use MockFileStore.list instead */
+export declare function listFakeFiles(path: string, filesRoot?: string): FileItem[];