@synopackageland/cli 0.1.0

package/dist/mock-broker/files.js

@@ -0,0 +1,408 @@
+import { copyFileSync, createReadStream, existsSync, mkdirSync, readdirSync, renameSync, rmSync, statSync, writeFileSync, } from "node:fs";
+import { dirname, join, posix } from "node:path";
+import { normalizeLogicalPath, parentAndName, PathValidationError } from "./path.js";
+export class FileStoreError extends Error {
+    code;
+    status;
+    constructor(code, status, message) {
+        super(message);
+        this.name = "FileStoreError";
+        this.code = code;
+        this.status = status;
+    }
+}
+const ERROR_MESSAGES = {
+    NOT_FOUND: "找不到這個路徑。",
+    CONFLICT: "目標已存在。",
+    INVALID_PATH: "路徑不合法。",
+    TRASH_UNAVAILABLE: "目標沒有可用的 trash／recycle bin，檔案未被刪除。",
+};
+function notFound() {
+    throw new FileStoreError("NOT_FOUND", 404, ERROR_MESSAGES.NOT_FOUND);
+}
+function conflict() {
+    throw new FileStoreError("CONFLICT", 409, ERROR_MESSAGES.CONFLICT);
+}
+function invalidPath() {
+    throw new FileStoreError("INVALID_PATH", 400, ERROR_MESSAGES.INVALID_PATH);
+}
+function trashUnavailable() {
+    throw new FileStoreError("TRASH_UNAVAILABLE", 409, ERROR_MESSAGES.TRASH_UNAVAILABLE);
+}
+function seedDefaultTree() {
+    const root = { type: "directory", children: new Map() };
+    const home = ensureDirNode(root, "/home");
+    home.children.set("docs", { type: "directory", children: new Map() });
+    home.children.set("notes", { type: "directory", children: new Map() });
+    home.children.set("readme.txt", {
+        type: "file",
+        content: Buffer.alloc(42),
+    });
+    return root;
+}
+function ensureDirNode(root, path) {
+    let node = root;
+    for (const part of path.split("/").filter(Boolean)) {
+        node.children ??= new Map();
+        let child = node.children.get(part);
+        if (!child) {
+            child = { type: "directory", children: new Map() };
+            node.children.set(part, child);
+        }
+        if (child.type !== "directory") {
+            conflict();
+        }
+        node = child;
+    }
+    return node;
+}
+function getNode(root, path) {
+    if (path === "/") {
+        return root;
+    }
+    let node = root;
+    for (const part of path.split("/").filter(Boolean)) {
+        node = node?.children?.get(part);
+        if (!node) {
+            return undefined;
+        }
+    }
+    return node;
+}
+function toItem(path, node) {
+    const name = path.split("/").filter(Boolean).at(-1) ?? path;
+    if (node.type === "directory") {
+        return { name, type: "directory", path };
+    }
+    return {
+        name,
+        type: "file",
+        path,
+        size: node.content?.length ?? 0,
+    };
+}
+function mapLogicalToAbsolute(logicalPath, filesRoot) {
+    const trimmed = logicalPath.replace(/\\/g, "/").replace(/\/+$/, "") || "/";
+    if (trimmed === "/") {
+        return filesRoot;
+    }
+    const normalized = normalizeLogicalPath(logicalPath);
+    const relative = normalized.replace(/^\//, "");
+    return join(filesRoot, relative);
+}
+export class MockFileStore {
+    filesRoot;
+    recycleBinDisabled;
+    treeRoot;
+    constructor(options = {}) {
+        this.filesRoot = options.filesRoot;
+        this.recycleBinDisabled = options.recycleBinDisabled ?? false;
+        this.treeRoot = seedDefaultTree();
+    }
+    list(rawPath) {
+        const path = this.resolveListPath(rawPath);
+        if (this.filesRoot) {
+            return this.listMapped(path);
+        }
+        return this.listMemory(path);
+    }
+    stat(rawPath) {
+        const path = this.resolveOperationPath(rawPath);
+        if (this.filesRoot) {
+            return this.statMapped(path);
+        }
+        return this.statMemory(path);
+    }
+    download(rawPath, range) {
+        const path = this.resolveOperationPath(rawPath);
+        if (this.filesRoot) {
+            return this.downloadMapped(path, range);
+        }
+        return this.downloadMemory(path, range);
+    }
+    upload(rawPath, body, overwrite = false) {
+        const path = this.resolveOperationPath(rawPath);
+        if (this.filesRoot) {
+            this.uploadMapped(path, body, overwrite);
+            return;
+        }
+        this.uploadMemory(path, body, overwrite);
+    }
+    mkdir(rawPath) {
+        const path = this.resolveOperationPath(rawPath);
+        if (this.filesRoot) {
+            this.mkdirMapped(path);
+            return;
+        }
+        this.mkdirMemory(path);
+    }
+    rename(rawPath, rawTo, overwrite = false) {
+        this.move(rawPath, rawTo, overwrite);
+    }
+    move(rawPath, rawTo, overwrite = false) {
+        const path = this.resolveOperationPath(rawPath);
+        const to = this.resolveOperationPath(rawTo);
+        if (this.filesRoot) {
+            this.moveMapped(path, to, overwrite);
+            return;
+        }
+        this.moveMemory(path, to, overwrite);
+    }
+    copy(rawPath, rawTo, overwrite = false) {
+        const path = this.resolveOperationPath(rawPath);
+        const to = this.resolveOperationPath(rawTo);
+        if (this.filesRoot) {
+            this.copyMapped(path, to, overwrite);
+            return;
+        }
+        this.copyMemory(path, to, overwrite);
+    }
+    trash(rawPath) {
+        if (this.recycleBinDisabled) {
+            trashUnavailable();
+        }
+        const path = this.resolveOperationPath(rawPath);
+        if (this.filesRoot) {
+            this.trashMapped(path);
+            return;
+        }
+        this.trashMemory(path);
+    }
+    resolveListPath(rawPath) {
+        const trimmed = rawPath.trim();
+        if (trimmed === "/" || trimmed === "") {
+            return "/";
+        }
+        try {
+            return normalizeLogicalPath(trimmed);
+        }
+        catch (error) {
+            if (error instanceof PathValidationError) {
+                invalidPath();
+            }
+            throw error;
+        }
+    }
+    resolveOperationPath(rawPath) {
+        try {
+            return normalizeLogicalPath(rawPath);
+        }
+        catch (error) {
+            if (error instanceof PathValidationError) {
+                invalidPath();
+            }
+            throw error;
+        }
+    }
+    listMemory(path) {
+        const node = getNode(this.treeRoot, path);
+        if (!node || node.type !== "directory") {
+            return [];
+        }
+        const items = [];
+        for (const [name, child] of node.children ?? []) {
+            items.push(toItem(posix.join(path, name), child));
+        }
+        return items;
+    }
+    statMemory(path) {
+        const node = getNode(this.treeRoot, path);
+        if (!node) {
+            notFound();
+        }
+        return toItem(path, node);
+    }
+    downloadMemory(path, range) {
+        const node = getNode(this.treeRoot, path);
+        if (!node || node.type !== "file") {
+            notFound();
+        }
+        const original = node.content ?? Buffer.alloc(0);
+        if (!range) {
+            return { buffer: original, size: original.length, totalSize: original.length };
+        }
+        const end = range.end ?? original.length - 1;
+        const slice = original.subarray(range.start, end + 1);
+        return { buffer: slice, size: slice.length, totalSize: original.length };
+    }
+    uploadMemory(path, body, overwrite) {
+        if (getNode(this.treeRoot, path) && !overwrite) {
+            conflict();
+        }
+        const { parent, name } = parentAndName(path);
+        const dir = ensureDirNode(this.treeRoot, parent);
+        dir.children ??= new Map();
+        dir.children.set(name, { type: "file", content: Buffer.from(body) });
+    }
+    mkdirMemory(path) {
+        if (getNode(this.treeRoot, path)) {
+            conflict();
+        }
+        ensureDirNode(this.treeRoot, path);
+    }
+    moveMemory(path, to, overwrite) {
+        const node = getNode(this.treeRoot, path);
+        if (!node) {
+            notFound();
+        }
+        if (getNode(this.treeRoot, to) && !overwrite) {
+            conflict();
+        }
+        const from = parentAndName(path);
+        const dest = parentAndName(to);
+        const fromDir = getNode(this.treeRoot, from.parent);
+        if (!fromDir?.children?.has(from.name)) {
+            notFound();
+        }
+        fromDir.children.delete(from.name);
+        const toDir = ensureDirNode(this.treeRoot, dest.parent);
+        toDir.children ??= new Map();
+        toDir.children.set(dest.name, node);
+    }
+    copyMemory(path, to, overwrite) {
+        const node = getNode(this.treeRoot, path);
+        if (!node) {
+            notFound();
+        }
+        if (getNode(this.treeRoot, to) && !overwrite) {
+            conflict();
+        }
+        const dest = parentAndName(to);
+        const toDir = ensureDirNode(this.treeRoot, dest.parent);
+        toDir.children ??= new Map();
+        toDir.children.set(dest.name, cloneNode(node));
+    }
+    trashMemory(path) {
+        const node = getNode(this.treeRoot, path);
+        if (!node) {
+            notFound();
+        }
+        const { parent, name } = parentAndName(path);
+        const parentNode = getNode(this.treeRoot, parent);
+        parentNode?.children?.delete(name);
+    }
+    listMapped(path) {
+        const absolute = mapLogicalToAbsolute(path, this.filesRoot);
+        let entries;
+        try {
+            entries = readdirSync(absolute);
+        }
+        catch {
+            return [];
+        }
+        const normalized = path.replace(/\/+$/, "") || "/";
+        return entries.map((name) => {
+            const childAbsolute = join(absolute, name);
+            const childLogical = posix.join(normalized === "/" ? "" : normalized, name);
+            const displayPath = childLogical.startsWith("/") ? childLogical : `/${childLogical}`;
+            const stat = statSync(childAbsolute);
+            if (stat.isDirectory()) {
+                return { name, type: "directory", path: displayPath };
+            }
+            return {
+                name,
+                type: "file",
+                path: displayPath,
+                size: stat.size,
+            };
+        });
+    }
+    statMapped(path) {
+        const absolute = mapLogicalToAbsolute(path, this.filesRoot);
+        if (!existsSync(absolute)) {
+            notFound();
+        }
+        const stat = statSync(absolute);
+        const name = path.split("/").filter(Boolean).at(-1) ?? path;
+        if (stat.isDirectory()) {
+            return { name, type: "directory", path };
+        }
+        return { name, type: "file", path, size: stat.size };
+    }
+    downloadMapped(path, range) {
+        const absolute = mapLogicalToAbsolute(path, this.filesRoot);
+        if (!existsSync(absolute)) {
+            notFound();
+        }
+        const stat = statSync(absolute);
+        if (!stat.isFile()) {
+            notFound();
+        }
+        const totalSize = stat.size;
+        if (!range) {
+            return {
+                stream: createReadStream(absolute),
+                size: totalSize,
+                totalSize,
+            };
+        }
+        const end = range.end ?? totalSize - 1;
+        const size = end - range.start + 1;
+        return {
+            stream: createReadStream(absolute, { start: range.start, end }),
+            size,
+            totalSize,
+        };
+    }
+    uploadMapped(path, body, overwrite) {
+        const absolute = mapLogicalToAbsolute(path, this.filesRoot);
+        if (existsSync(absolute) && !overwrite) {
+            conflict();
+        }
+        mkdirSync(dirname(absolute), { recursive: true });
+        writeFileSync(absolute, body);
+    }
+    mkdirMapped(path) {
+        const absolute = mapLogicalToAbsolute(path, this.filesRoot);
+        if (existsSync(absolute)) {
+            conflict();
+        }
+        mkdirSync(absolute, { recursive: true });
+    }
+    moveMapped(path, to, overwrite) {
+        const fromAbsolute = mapLogicalToAbsolute(path, this.filesRoot);
+        const toAbsolute = mapLogicalToAbsolute(to, this.filesRoot);
+        if (!existsSync(fromAbsolute)) {
+            notFound();
+        }
+        if (existsSync(toAbsolute) && !overwrite) {
+            conflict();
+        }
+        mkdirSync(dirname(toAbsolute), { recursive: true });
+        renameSync(fromAbsolute, toAbsolute);
+    }
+    copyMapped(path, to, overwrite) {
+        const fromAbsolute = mapLogicalToAbsolute(path, this.filesRoot);
+        const toAbsolute = mapLogicalToAbsolute(to, this.filesRoot);
+        if (!existsSync(fromAbsolute)) {
+            notFound();
+        }
+        if (existsSync(toAbsolute) && !overwrite) {
+            conflict();
+        }
+        mkdirSync(dirname(toAbsolute), { recursive: true });
+        copyFileSync(fromAbsolute, toAbsolute);
+    }
+    trashMapped(path) {
+        const absolute = mapLogicalToAbsolute(path, this.filesRoot);
+        if (!existsSync(absolute)) {
+            notFound();
+        }
+        rmSync(absolute, { recursive: true, force: true });
+    }
+}
+function cloneNode(node) {
+    if (node.type === "file") {
+        return { type: "file", content: node.content ? Buffer.from(node.content) : Buffer.alloc(0) };
+    }
+    const children = new Map();
+    for (const [name, child] of node.children ?? []) {
+        children.set(name, cloneNode(child));
+    }
+    return { type: "directory", children };
+}
+/** @deprecated Use MockFileStore.list instead */
+export function listFakeFiles(path, filesRoot) {
+    const store = new MockFileStore({ filesRoot });
+    return store.list(path);
+}

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

@@ -0,0 +1,31 @@
+import type { IncomingMessage, ServerResponse } from "node:http";
+export declare const MOCK_OIDC_CLIENT_SECRET = "mock-oidc-secret";
+export declare const MOCK_OIDC_REDIRECT_PATH = "/api/auth/sso_callback";
+export declare const MOCK_OIDC_KID_PREFIX = "oidc-";
+export interface MockOidcUser {
+    subject: string;
+    username: string;
+    displayName: string;
+}
+export interface MockOidcOptions {
+    clientId?: string;
+    clientSecret?: string;
+    redirectUri?: string;
+}
+interface AuthCode {
+    code: string;
+    clientId: string;
+    redirectUri: string;
+    consumed: boolean;
+}
+export interface MockOidcContext {
+    packageId: string;
+    clientId: string;
+    clientSecret: string;
+    redirectUri: string;
+    user: MockOidcUser;
+    codes: Map<string, AuthCode>;
+}
+export declare function createMockOidcContext(packageId: string, user: MockOidcUser, options?: MockOidcOptions): MockOidcContext;
+export declare function handleMockOidc(req: IncomingMessage, res: ServerResponse, url: URL, ctx: MockOidcContext): Promise<boolean>;
+export {};

package/dist/mock-broker/oidc.js

@@ -0,0 +1,161 @@
+import { createHash, randomBytes, randomUUID } from "node:crypto";
+import { exportJWK, generateKeyPair, SignJWT } from "jose";
+export const MOCK_OIDC_CLIENT_SECRET = "mock-oidc-secret";
+export const MOCK_OIDC_REDIRECT_PATH = "/api/auth/sso_callback";
+export const MOCK_OIDC_KID_PREFIX = "oidc-";
+let oidcKeyPromise = null;
+async function oidcKeys() {
+    if (!oidcKeyPromise) {
+        oidcKeyPromise = generateKeyPair("RS256");
+    }
+    return oidcKeyPromise;
+}
+function sendJson(res, status, body) {
+    res.statusCode = status;
+    res.setHeader("content-type", "application/json; charset=utf-8");
+    res.end(JSON.stringify(body));
+}
+function sendOAuthError(res, status, error) {
+    sendJson(res, status, { error });
+}
+function secretsEqual(left, right) {
+    return left.length === right.length && left === right;
+}
+function issuerFromRequest(req) {
+    const host = req.headers.host ?? "127.0.0.1";
+    return `http://${host}/oidc`;
+}
+function discovery(issuer) {
+    const base = issuer.replace(/\/$/, "");
+    return {
+        issuer: base,
+        authorization_endpoint: `${base}/authorize`,
+        token_endpoint: `${base}/token`,
+        jwks_uri: `${base}/jwks`,
+        response_types_supported: ["code"],
+        grant_types_supported: ["authorization_code"],
+        subject_types_supported: ["public"],
+        id_token_signing_alg_values_supported: ["RS256"],
+        token_endpoint_auth_methods_supported: ["client_secret_post"],
+        scopes_supported: ["openid"],
+        claims_supported: ["iss", "sub", "aud", "exp", "iat", "preferred_username", "name"],
+    };
+}
+async function oidcKid() {
+    const { publicKey } = await oidcKeys();
+    const jwk = await exportJWK(publicKey);
+    return `${MOCK_OIDC_KID_PREFIX}${createHash("sha256")
+        .update(JSON.stringify(jwk))
+        .digest("hex")
+        .slice(0, 16)}`;
+}
+async function issueIdToken(issuer, clientId, user) {
+    const { privateKey } = await oidcKeys();
+    const kid = await oidcKid();
+    return new SignJWT({
+        preferred_username: user.username,
+        name: user.username,
+        mock: true,
+    })
+        .setProtectedHeader({ alg: "RS256", kid })
+        .setIssuer(issuer)
+        .setAudience(clientId)
+        .setSubject(user.subject)
+        .setIssuedAt()
+        .setExpirationTime("15m")
+        .sign(privateKey);
+}
+function readBody(req) {
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        req.on("data", (chunk) => chunks.push(Buffer.from(chunk)));
+        req.on("end", () => resolve(Buffer.concat(chunks).toString("utf8")));
+        req.on("error", reject);
+    });
+}
+export function createMockOidcContext(packageId, user, options) {
+    return {
+        packageId,
+        clientId: options?.clientId ?? packageId,
+        clientSecret: options?.clientSecret ?? MOCK_OIDC_CLIENT_SECRET,
+        redirectUri: options?.redirectUri ?? `http://127.0.0.1${MOCK_OIDC_REDIRECT_PATH}`,
+        user,
+        codes: new Map(),
+    };
+}
+export async function handleMockOidc(req, res, url, ctx) {
+    const pathname = (url.pathname.replace(/\/$/, "") || "/");
+    if (!pathname.startsWith("/oidc")) {
+        return false;
+    }
+    const issuer = issuerFromRequest(req);
+    if (req.method === "GET" && pathname === "/oidc/.well-known/openid-configuration") {
+        sendJson(res, 200, discovery(issuer));
+        return true;
+    }
+    if (req.method === "GET" && pathname === "/oidc/jwks") {
+        const { publicKey } = await oidcKeys();
+        const jwk = await exportJWK(publicKey);
+        jwk.alg = "RS256";
+        jwk.use = "sig";
+        jwk.kid = await oidcKid();
+        sendJson(res, 200, { keys: [jwk] });
+        return true;
+    }
+    if (req.method === "GET" && pathname === "/oidc/authorize") {
+        const clientId = url.searchParams.get("client_id") ?? "";
+        const redirectUri = url.searchParams.get("redirect_uri") ?? "";
+        const responseType = url.searchParams.get("response_type") ?? "";
+        const state = url.searchParams.get("state");
+        if (clientId !== ctx.clientId || redirectUri !== ctx.redirectUri) {
+            sendOAuthError(res, 400, "invalid_request");
+            return true;
+        }
+        if (responseType !== "code") {
+            sendOAuthError(res, 400, "unsupported_response_type");
+            return true;
+        }
+        const code = randomUUID();
+        ctx.codes.set(code, { code, clientId, redirectUri, consumed: false });
+        const location = new URL(redirectUri);
+        location.searchParams.set("code", code);
+        if (state) {
+            location.searchParams.set("state", state);
+        }
+        res.statusCode = 302;
+        res.setHeader("location", location.toString());
+        res.end();
+        return true;
+    }
+    if (req.method === "POST" && pathname === "/oidc/token") {
+        const text = await readBody(req);
+        const body = Object.fromEntries(new URLSearchParams(text).entries());
+        if (body.client_id !== ctx.clientId || !secretsEqual(body.client_secret ?? "", ctx.clientSecret)) {
+            sendOAuthError(res, 401, "invalid_client");
+            return true;
+        }
+        if (body.grant_type !== "authorization_code") {
+            sendOAuthError(res, 400, "unsupported_grant_type");
+            return true;
+        }
+        const record = ctx.codes.get(body.code ?? "");
+        if (!record ||
+            record.consumed ||
+            record.clientId !== body.client_id ||
+            record.redirectUri !== (body.redirect_uri ?? "")) {
+            sendOAuthError(res, 400, "invalid_grant");
+            return true;
+        }
+        record.consumed = true;
+        const idToken = await issueIdToken(issuer, ctx.clientId, ctx.user);
+        sendJson(res, 200, {
+            id_token: idToken,
+            access_token: randomBytes(24).toString("base64url"),
+            token_type: "Bearer",
+            expires_in: 15 * 60,
+        });
+        return true;
+    }
+    sendOAuthError(res, 404, "invalid_request");
+    return true;
+}

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

@@ -0,0 +1,9 @@
+export declare class PathValidationError extends Error {
+    readonly code: "INVALID_PATH";
+    constructor();
+}
+export declare function normalizeLogicalPath(raw: string): string;
+export declare function parentAndName(logicalPath: string): {
+    parent: string;
+    name: string;
+};

package/dist/mock-broker/path.js

@@ -0,0 +1,50 @@
+export class PathValidationError extends Error {
+    code = "INVALID_PATH";
+    constructor() {
+        super("路徑不合法。");
+        this.name = "PathValidationError";
+    }
+}
+const MAX_PATH_LENGTH = 4096;
+export function normalizeLogicalPath(raw) {
+    if (typeof raw !== "string" || raw.length === 0) {
+        throw new PathValidationError();
+    }
+    if (raw.includes("\0") || raw.length > MAX_PATH_LENGTH) {
+        throw new PathValidationError();
+    }
+    const unified = raw.replace(/\\/g, "/");
+    if (!unified.startsWith("/")) {
+        throw new PathValidationError();
+    }
+    if (/^\/volume\d+/i.test(unified) ||
+        unified.startsWith("/volumeUSB") ||
+        unified.startsWith("/volumeSATA")) {
+        throw new PathValidationError();
+    }
+    const parts = [];
+    for (const segment of unified.split("/")) {
+        if (segment === "" || segment === ".") {
+            continue;
+        }
+        if (segment === "..") {
+            throw new PathValidationError();
+        }
+        parts.push(segment);
+    }
+    if (parts.length === 0) {
+        throw new PathValidationError();
+    }
+    return `/${parts.join("/")}`;
+}
+export function parentAndName(logicalPath) {
+    const normalized = normalizeLogicalPath(logicalPath);
+    const idx = normalized.lastIndexOf("/");
+    if (idx <= 0) {
+        throw new PathValidationError();
+    }
+    return {
+        parent: normalized.slice(0, idx) || "/",
+        name: normalized.slice(idx + 1),
+    };
+}

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

@@ -0,0 +1,19 @@
+import { type Server } from "node:http";
+import type { SynologyUser } from "@synopackageland/dev-sdk/node";
+import { type MockOidcOptions } from "./oidc.js";
+export declare const FAKE_USER: SynologyUser;
+export interface MockBrokerOptions {
+    packageId: string;
+    filesRoot?: string;
+    recycleBinDisabled?: boolean;
+    port?: number;
+    oidc?: MockOidcOptions;
+}
+export interface MockBrokerHandle {
+    baseUrl: string;
+    jwksUrl: string;
+    packageId: string;
+    server: Server;
+    close(): Promise<void>;
+}
+export declare function startMockBroker(options: MockBrokerOptions): Promise<MockBrokerHandle>;