@synopackageland/cli 0.5.0 → 0.6.0

package/dist/compose/analyze.js

@@ -320,7 +320,7 @@ function collectPermanentRouteErrors(contract, parsed, composeFile) {
             const basePath = `services.${serviceName}`;
             if ("build" in service && service.build !== undefined) {
                 const path = `${basePath}.build`;
-                errors.push(makeError("COMPOSE_BUILD_FORBIDDEN", composeSpanForPath(compose, composeFile, path), `service「${serviceName}」宣告 build:；D0 route 不支援 install-time build。`, "請移除 build:，改用已存在的 image（最好使用 image@sha256:... 固定 digest），再重新執行 validate。"));
+                errors.push(makeError("COMPOSE_BUILD_FORBIDDEN", composeSpanForPath(compose, composeFile, path), `service「${serviceName}」宣告 build:；D0 route 不支援 install-time build。`, "請移除 build:，改用已存在的 image（最好使用 image@sha256:... 固定 digest），再重新執行 check。"));
             }
             if (dsmUserParams.length > 0 && typeof service.user === "string" && service.user.trim() !== "") {
                 const path = `${basePath}.user`;
@@ -404,7 +404,7 @@ function collectDynamicRouteError(contract, parsed, composeFile) {
         reasonText +
         "）；這條 route 會拒收，不會靜默改用其他執行方式。", undeclaredName
         ? interpolationSuggestion
-        : `${interpolationSuggestion} secret/config 因 DSM worker 不讀 docker-compose.override.yml 而拒收，請移除後重新執行 validate。`);
+        : `${interpolationSuggestion} secret/config 因 DSM worker 不讀 docker-compose.override.yml 而拒收，請移除後重新執行 check。`);
 }
 function parsedComposeForAnalysis(compose) {
     const source = composeSources.get(compose) ?? "";

package/dist/contract/unsupported-types.js

@@ -6,7 +6,7 @@ import { collectInstallParameters } from "./load.js";
  * Measured on vt-nas 2026-08-27: both end in DSM broken/150 with no Container
  * Manager project, while a no-parameter control package installed fine on the
  * same NAS. `secret` renders its password field and fails; `homes` renders no
- * input at all. `validate` reports these as warnings so build-spk keeps working
+ * input at all. `check` reports these as warnings so build keeps working
  * for fixtures that declare them incidentally -- the refusal belongs at the two
  * gates that actually put an App somewhere: deploy and publish.
  */

package/dist/deploy/deploy.d.ts

@@ -5,7 +5,7 @@ import type { NasHost } from "../host/types.js";
 import { resolveDeploySpkVersion } from "./spk-version.js";
 export interface DeployProjectOptions {
     project: ProjectRoot;
-    /** native App only: which target to build. Omitted means "ask the NAS". */
+    /** Gateway architecture. Omitted means "ask the NAS" when needed. */
     archFamily?: NativeArchFamily;
     host: NasHost;
     dev?: boolean;

package/dist/deploy/deploy.js

@@ -1,5 +1,4 @@
 import { buildSpk } from "../build-spk/generator.js";
-import { existsSync } from "node:fs";
 import { loadContract } from "../contract/load.js";
 import { usesAuthGateway } from "../contract/web-launch.js";
 import { findUnsupportedInstallTypes } from "../contract/unsupported-types.js";
@@ -164,9 +163,8 @@ export async function deployProject(options) {
             message: error instanceof Error ? error.message : String(error) };
     }
     let archFamily = options.archFamily;
-    const isNative = options.project.nativePath !== undefined && existsSync(options.project.nativePath);
     // A DSM-authenticated web App ships a native gateway CGI, so it is built per architecture too.
-    if (archFamily === undefined && (isNative || usesAuthGateway(contract))) {
+    if (archFamily === undefined && usesAuthGateway(contract)) {
         archFamily = await options.host.getArchFamily?.();
         if (archFamily === undefined) {
             return {

package/dist/deploy/plan.d.ts

@@ -6,7 +6,7 @@ export interface DeploymentPlan {
     packageId: string;
     version: string;
     arch?: NativeArchFamily;
-    privilege: "none" | "root";
+    capabilities: string[];
     transport: "dsm-local-spk";
     notes: string[];
 }

package/dist/deploy/plan.js

@@ -1,54 +1,85 @@
-import { existsSync } from "node:fs";
-import { join } from "node:path";
 import { findProjectRoot } from "../discovery.js";
 import { loadContract } from "../contract/load.js";
 import { validateProject } from "../validate.js";
-import { findStandaloneRoot, loadStandaloneManifest } from "../standalone/manifest.js";
+import { findStandaloneRoot, loadStandaloneManifest, } from "../standalone/manifest.js";
 import { buildStandalone } from "../standalone/build.js";
 import { resolveDeployIdentity } from "./identity.js";
 import { nextDeployVersion } from "./spk-version.js";
+function fail(code, message) {
+    return Object.assign(new Error(`[${code}] ${message}`), { code });
+}
 /** Purely local planning: no credentials, network, build or installation. */
 export function planDeployment(root, options = {}) {
     const standalone = findStandaloneRoot(root);
     if (standalone) {
+        const validation = validateProject(findProjectRoot(standalone));
+        if (!validation.ok)
+            throw fail(validation.errors[0].code, validation.errors.map((e) => e.message).join("\n"));
         const loaded = loadStandaloneManifest(standalone);
         if (!loaded.ok)
-            throw new Error(loaded.errors.map(e => `${e.code}: ${e.message}`).join("\n"));
+            throw fail(loaded.errors[0].code, loaded.errors.map((e) => `${e.code}: ${e.message}`).join("\n"));
         const m = loaded.manifest;
         if (options.dev)
-            throw new Error('--dev is not supported for native-go; choose a distinct package name at init');
+            throw fail("DEVELOPMENT_INSTANCE_UNSUPPORTED", "--dev is not supported for native-go/binary; choose a distinct package name at init");
         if (options.arch && !m.arches.includes(options.arch))
-            throw new Error(`Architecture not declared: ${options.arch}`);
-        return { root: standalone, kind: "native-go", packageId: m.package, version: m.spkVersion,
-            arch: options.arch, privilege: m.privilege, transport: "dsm-local-spk",
-            notes: m.privilege === "root" ? ['Approve root tasks in DSM after installation; changed task text requires fresh approval. Remove tasks before uninstall.'] : [] };
+            throw fail("STANDALONE_ARCH_NOT_DECLARED", `Architecture not declared: ${options.arch}`);
+        return {
+            root: standalone,
+            kind: m.backend.kind === "go" ? "native-go" : "binary",
+            packageId: m.package,
+            version: m.spkVersion,
+            arch: options.arch,
+            capabilities: Object.keys(m.capabilities),
+            transport: "dsm-local-spk",
+            notes: m.capabilities.rootOps || m.capabilities.delegate
+                ? [
+                    "Installation does not mean ready. Approve boot and control tasks once in the App window; executor or policy digest changes require approval again.",
+                ]
+                : [],
+        };
     }
     const project = findProjectRoot(root);
     if (!project)
-        throw new Error('No dsm-package.yaml or synology-app.yaml found');
+        throw fail("PROJECT_NOT_FOUND", "No dsm-package.yaml or synology-app.yaml found");
     const validation = validateProject(project);
     if (!validation.ok)
-        throw new Error(validation.errors.map(e => `${e.code}: ${e.message}`).join("\n"));
+        throw fail(validation.errors[0].code, validation.errors.map((e) => `${e.code}: ${e.message}`).join("\n"));
     const contract = loadContract(project.contractPath).contract;
     const identity = resolveDeployIdentity(project, { dev: options.dev });
-    return { root: project.root, kind: existsSync(join(project.root, 'native.yaml')) ? 'binary' : 'container',
-        packageId: identity.packageId, version: nextDeployVersion(String(contract.version)),
-        arch: options.arch, privilege: 'none', transport: 'dsm-local-spk',
-        notes: ['DSM resolves target architecture and installed version during deployment. Container bind access uses the configured process user.'] };
+    return {
+        root: project.root,
+        kind: "container",
+        packageId: identity.packageId,
+        version: nextDeployVersion(String(contract.version)),
+        arch: options.arch,
+        capabilities: [],
+        transport: "dsm-local-spk",
+        notes: [
+            "DSM resolves target architecture and installed version during deployment. Container bind access uses the configured process user.",
+        ],
+    };
 }
 export async function deployStandalone(plan, host) {
-    if (plan.kind !== 'native-go')
-        throw new Error('Expected native-go deployment plan');
-    const arch = plan.arch ?? await host.getArchFamily?.();
+    if (plan.kind === "container")
+        throw fail("DEPLOY_PLAN_INVALID", "Expected native-go or binary deployment plan");
+    const arch = plan.arch ?? (await host.getArchFamily?.());
     if (!arch)
-        throw new Error('Cannot determine NAS architecture; specify --arch');
+        throw fail("DEPLOY_ARCH_UNDETERMINED", "Cannot determine NAS architecture; specify --arch");
     const installed = await host.getInstalledPackageVersion?.(plan.packageId);
-    if (installed && nextDeployVersion(plan.version, installed) !== plan.version) {
-        throw new Error(`Increase dsm-package.yaml version/build above installed ${installed}`);
+    if (installed &&
+        nextDeployVersion(plan.version, installed) !== plan.version) {
+        throw fail("DEPLOY_VERSION_INVALID", `Increase dsm-package.yaml version/build above installed ${installed}`);
     }
-    const { outputs } = await buildStandalone({ root: plan.root, arches: [arch] });
+    const { outputs } = await buildStandalone({
+        root: plan.root,
+        arches: [arch],
+    });
     if (outputs.length !== 1)
-        throw new Error('Expected one SPK');
-    await host.installFromLocalSpk({ packageId: plan.packageId, version: plan.version, spkPath: outputs[0] });
+        throw fail("DEPLOY_BUILD_OUTPUT_INVALID", "Expected one SPK");
+    await host.installFromLocalSpk({
+        packageId: plan.packageId,
+        version: plan.version,
+        spkPath: outputs[0],
+    });
     return outputs[0];
 }

package/dist/discovery.d.ts

@@ -1,10 +1,9 @@
 export declare const CONTRACT_FILENAME = "synology-app.yaml";
 export declare const COMPOSE_FILENAME = "compose.yaml";
-export declare const NATIVE_FILENAME = "native.yaml";
+export declare const DSM_PACKAGE_FILENAME = "dsm-package.yaml";
 export interface ProjectRoot {
     root: string;
     contractPath: string;
     composePath: string;
-    nativePath?: string;
 }
 export declare function findProjectRoot(startDir: string): ProjectRoot | null;

package/dist/discovery.js

@@ -2,17 +2,17 @@ import { existsSync } from "node:fs";
 import { dirname, join, resolve } from "node:path";
 export const CONTRACT_FILENAME = "synology-app.yaml";
 export const COMPOSE_FILENAME = "compose.yaml";
-export const NATIVE_FILENAME = "native.yaml";
+export const DSM_PACKAGE_FILENAME = "dsm-package.yaml";
 export function findProjectRoot(startDir) {
     let current = resolve(startDir);
     while (true) {
-        const contractPath = join(current, CONTRACT_FILENAME);
+        const standalonePath = join(current, DSM_PACKAGE_FILENAME);
+        const contractPath = existsSync(standalonePath) ? standalonePath : join(current, CONTRACT_FILENAME);
         if (existsSync(contractPath)) {
             return {
                 root: current,
                 contractPath,
                 composePath: join(current, COMPOSE_FILENAME),
-                nativePath: join(current, NATIVE_FILENAME),
             };
         }
         const parent = dirname(current);