@luckypiggy/zhihu-ai-cli 0.1.0-test.1

package/dist/config.js

@@ -0,0 +1,350 @@
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import { chmodSync, lstatSync, mkdirSync, readFileSync, renameSync, unlinkSync, writeFileSync, } from "node:fs";
+import { CONFIG_SCHEMA_VERSION } from "./contracts.js";
+export const DEFAULT_PROFILE_NAME = "default";
+export const DEFAULT_PROFILE = {
+    base_url: "",
+    timeout_seconds: 30,
+    language: "en",
+};
+export class ConfigError extends Error {
+    code;
+    constructor(message, code = "CONFIG_INVALID") {
+        super(message);
+        this.name = "ConfigError";
+        this.code = code;
+    }
+}
+/** Stable, non-secret failure raised when changing an authenticated profile origin. */
+export class ProfileConnectionGuardError extends Error {
+    code;
+    exitCode = 3;
+    constructor(code, message) {
+        super(message);
+        this.name = "ProfileConnectionGuardError";
+        this.code = code;
+    }
+}
+function homeDirectory(environment) {
+    return environment.HOME?.trim() || homedir();
+}
+export function configRoot(environment = process.env) {
+    const xdg = environment.XDG_CONFIG_HOME?.trim();
+    return join(xdg || join(homeDirectory(environment), ".config"), "zhihu-ai");
+}
+export function rootConfigPath(environment = process.env) {
+    return join(configRoot(environment), "config.json");
+}
+export function profilePath(profileName, environment = process.env) {
+    return join(configRoot(environment), "profiles", `${normalizeProfileName(profileName)}.json`);
+}
+export function normalizeProfileName(value) {
+    const name = value.trim();
+    if (!/^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/.test(name)) {
+        throw new ConfigError("Profile name must use letters, numbers, dot, underscore, or hyphen");
+    }
+    return name;
+}
+function readJsonFile(path) {
+    try {
+        return JSON.parse(readFileSync(path, "utf8"));
+    }
+    catch (error) {
+        if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") {
+            return undefined;
+        }
+        throw new ConfigError(`Unable to read configuration file: ${path}`);
+    }
+}
+function objectOrEmpty(value, label) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        throw new ConfigError(`${label} must be a JSON object`);
+    }
+    return value;
+}
+export function readRootConfig(environment = process.env) {
+    const raw = readJsonFile(rootConfigPath(environment));
+    if (raw === undefined) {
+        return { schema_version: CONFIG_SCHEMA_VERSION, current_profile: DEFAULT_PROFILE_NAME };
+    }
+    const object = objectOrEmpty(raw, "Root configuration");
+    const schemaVersion = object.schema_version;
+    const currentProfile = object.current_profile;
+    if (schemaVersion !== CONFIG_SCHEMA_VERSION || typeof currentProfile !== "string") {
+        throw new ConfigError("Root configuration schema is not supported");
+    }
+    return {
+        schema_version: schemaVersion,
+        current_profile: normalizeProfileName(currentProfile),
+    };
+}
+export function readProfileRaw(profileName, environment = process.env) {
+    return readJsonFile(profilePath(profileName, environment));
+}
+function optionalString(object, key) {
+    if (object[key] === undefined)
+        return undefined;
+    if (typeof object[key] !== "string" || object[key].length > 4096) {
+        throw new ConfigError(`Profile field ${key} must be a string`);
+    }
+    return object[key];
+}
+function validateBaseUrl(value) {
+    if (value === undefined || value === "")
+        return "";
+    if (typeof value !== "string" || value.length > 2048) {
+        throw new ConfigError("Profile base_url must be an HTTP(S) URL");
+    }
+    let parsed;
+    try {
+        parsed = new URL(value);
+    }
+    catch {
+        throw new ConfigError("Profile base_url must be an HTTP(S) URL");
+    }
+    if (!/^https?:$/.test(parsed.protocol) || parsed.username || parsed.password || parsed.search || parsed.hash) {
+        throw new ConfigError("Profile base_url must not contain credentials, query, or fragment");
+    }
+    return parsed.toString().replace(/\/$/, "");
+}
+export function validateProfile(value) {
+    const object = objectOrEmpty(value ?? {}, "Profile configuration");
+    const allowed = new Set(["base_url", "timeout_seconds", "language", "ca_bundle", "codex_skill_dir"]);
+    for (const key of Object.keys(object)) {
+        if (!allowed.has(key))
+            throw new ConfigError(`Profile field ${key} is not supported`);
+    }
+    const timeout = object.timeout_seconds ?? DEFAULT_PROFILE.timeout_seconds;
+    if (typeof timeout !== "number" || !Number.isInteger(timeout) || timeout < 1 || timeout > 300) {
+        throw new ConfigError("Profile timeout_seconds must be an integer between 1 and 300");
+    }
+    const language = object.language ?? DEFAULT_PROFILE.language;
+    if (language !== "zh" && language !== "en")
+        throw new ConfigError("Profile language must be zh or en");
+    const caBundle = optionalString(object, "ca_bundle");
+    const codexSkillDir = optionalString(object, "codex_skill_dir");
+    return {
+        base_url: validateBaseUrl(object.base_url),
+        timeout_seconds: timeout,
+        language,
+        ...(caBundle ? { ca_bundle: caBundle } : {}),
+        ...(codexSkillDir ? { codex_skill_dir: codexSkillDir } : {}),
+    };
+}
+/**
+ * Connection identity is deliberately limited to the service origin and the
+ * trust bundle.  Timeout, language, and local Skill settings can be changed
+ * in-place without invalidating an existing login.
+ */
+export function profileConnectionIdentityChanged(previous, next) {
+    return previous.base_url !== next.base_url
+        || (previous.ca_bundle ?? undefined) !== (next.ca_bundle ?? undefined);
+}
+/**
+ * Refuse to silently move a profile with an active credential to a new
+ * service origin.  Callers hold the global and target profile locks while
+ * invoking this guard.  The probe is injected so tests never touch a real
+ * keychain/secret service.
+ */
+export async function guardProfileConnectionChange(profileName, previous, next, credentialStoreFactory) {
+    if (!profileConnectionIdentityChanged(previous, next))
+        return;
+    let store;
+    try {
+        store = credentialStoreFactory(profileName);
+        if (!(await store.available())) {
+            throw new Error("credential store unavailable");
+        }
+        const credential = await store.get();
+        if (credential) {
+            throw new ProfileConnectionGuardError("AUTH_ALREADY_LOGGED_IN", `Profile ${profileName} has an active login on another Pilot origin; run zhihu auth logout --profile ${profileName} or use a new profile`);
+        }
+    }
+    catch (error) {
+        if (error instanceof ProfileConnectionGuardError)
+            throw error;
+        throw new ProfileConnectionGuardError("CREDENTIAL_STORE_UNAVAILABLE", `Unable to verify existing credentials for profile ${profileName}; run zhihu auth logout --profile ${profileName} before changing the Pilot origin`);
+    }
+}
+export function writeJsonAtomic(path, value) {
+    mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
+    const temporaryPath = `${path}.tmp-${process.pid}-${Date.now()}`;
+    try {
+        writeFileSync(temporaryPath, `${JSON.stringify(value, null, 2)}\n`, { mode: 0o600 });
+        chmodSync(temporaryPath, 0o600);
+        renameSync(temporaryPath, path);
+    }
+    finally {
+        // A failed write or rename must not leave a stale temporary file that
+        // could be mistaken for a valid configuration on the next invocation.
+        try {
+            unlinkSync(temporaryPath);
+        }
+        catch (error) {
+            if (!(error && typeof error === "object" && "code" in error && error.code === "ENOENT")) {
+                // The primary write error is more actionable; callers still restore
+                // the pair of configuration files and report any rollback failure.
+            }
+        }
+    }
+}
+function snapshotFile(path) {
+    try {
+        const stat = lstatSync(path);
+        if (stat.isSymbolicLink() || !stat.isFile()) {
+            throw new ConfigError("Configuration file must be a regular file");
+        }
+        return { path, exists: true, content: readFileSync(path, "utf8"), mode: stat.mode & 0o777 };
+    }
+    catch (error) {
+        if (error instanceof ConfigError)
+            throw error;
+        if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") {
+            return { path, exists: false };
+        }
+        throw new ConfigError("Unable to inspect configuration file");
+    }
+}
+/** Capture and restore both files touched by a profile install. */
+export function captureProfileInstallSnapshot(profileName, environment = process.env) {
+    const name = normalizeProfileName(profileName);
+    return {
+        profile: snapshotFile(profilePath(name, environment)),
+        root: snapshotFile(rootConfigPath(environment)),
+    };
+}
+function restoreSnapshot(snapshot) {
+    if (snapshot.exists) {
+        try {
+            const current = lstatSync(snapshot.path);
+            if (current.isSymbolicLink() || !current.isFile())
+                throw new ConfigError("Configuration rollback target is unsafe");
+        }
+        catch (error) {
+            if (error instanceof ConfigError)
+                throw error;
+            if (!(error && typeof error === "object" && "code" in error && error.code === "ENOENT")) {
+                throw new ConfigError("Unable to restore configuration");
+            }
+        }
+        const temporaryPath = `${snapshot.path}.rollback-${process.pid}-${Date.now()}`;
+        try {
+            writeFileSync(temporaryPath, snapshot.content ?? "", { mode: snapshot.mode ?? 0o600 });
+            chmodSync(temporaryPath, snapshot.mode ?? 0o600);
+            renameSync(temporaryPath, snapshot.path);
+        }
+        catch {
+            try {
+                unlinkSync(temporaryPath);
+            }
+            catch { /* best effort cleanup */ }
+            throw new ConfigError("Unable to restore configuration");
+        }
+        return;
+    }
+    try {
+        // A missing snapshot means an install created this file.  Unlink only the
+        // exact regular file; never recurse or follow a symlink during rollback.
+        const stat = lstatSync(snapshot.path);
+        if (stat.isSymbolicLink() || !stat.isFile())
+            throw new ConfigError("Configuration rollback target is unsafe");
+        unlinkSync(snapshot.path);
+    }
+    catch (error) {
+        if (error instanceof ConfigError)
+            throw error;
+        if (error && typeof error === "object" && "code" in error && error.code === "ENOENT")
+            return;
+        throw new ConfigError("Unable to restore configuration");
+    }
+}
+export function restoreProfileInstallSnapshot(snapshot) {
+    let failure = false;
+    try {
+        restoreSnapshot(snapshot.profile);
+    }
+    catch {
+        failure = true;
+    }
+    try {
+        restoreSnapshot(snapshot.root);
+    }
+    catch {
+        failure = true;
+    }
+    if (failure)
+        throw new ConfigError("Unable to restore configuration");
+}
+export function writeProfileInstallConfig(profileName, profile, environment = process.env) {
+    const name = normalizeProfileName(profileName);
+    const snapshot = captureProfileInstallSnapshot(name, environment);
+    try {
+        writeJsonAtomic(profilePath(name, environment), validateProfile(profile));
+        writeJsonAtomic(rootConfigPath(environment), {
+            schema_version: CONFIG_SCHEMA_VERSION,
+            current_profile: name,
+        });
+    }
+    catch (error) {
+        try {
+            restoreProfileInstallSnapshot(snapshot);
+        }
+        catch {
+            throw new ConfigError("Configuration write failed and local configuration could not be restored");
+        }
+        throw error;
+    }
+    return snapshot;
+}
+export function initializeProfile(profileName, partial, environment = process.env, force = false) {
+    const name = normalizeProfileName(profileName);
+    const destination = profilePath(name, environment);
+    if (!force && readProfileRaw(name, environment) !== undefined) {
+        throw new ConfigError(`Profile ${name} already exists`, "CONFIG_EXISTS");
+    }
+    const profile = validateProfile({ ...DEFAULT_PROFILE, ...partial });
+    const snapshot = captureProfileInstallSnapshot(name, environment);
+    try {
+        writeJsonAtomic(destination, profile);
+        writeJsonAtomic(rootConfigPath(environment), {
+            schema_version: CONFIG_SCHEMA_VERSION,
+            current_profile: name,
+        });
+    }
+    catch (error) {
+        try {
+            restoreProfileInstallSnapshot(snapshot);
+        }
+        catch {
+            throw new ConfigError("Configuration write failed and local configuration could not be restored");
+        }
+        throw error;
+    }
+    return profile;
+}
+export function readConfigSnapshot(environment = process.env, requestedProfile) {
+    const root = readRootConfig(environment);
+    const selectedProfile = normalizeProfileName(requestedProfile || root.current_profile);
+    const profile = readProfileRaw(selectedProfile, environment) ?? DEFAULT_PROFILE;
+    return {
+        root_path: rootConfigPath(environment),
+        profile_path: profilePath(selectedProfile, environment),
+        selected_profile: selectedProfile,
+        root,
+        profile,
+    };
+}
+export function checkProfile(environment = process.env, requestedProfile) {
+    const snapshot = readConfigSnapshot(environment, requestedProfile);
+    try {
+        return { snapshot, profile: validateProfile(snapshot.profile) };
+    }
+    catch (error) {
+        return {
+            snapshot,
+            profile: undefined,
+            error: error instanceof ConfigError ? error.message : "Invalid profile configuration",
+        };
+    }
+}

package/dist/contracts.js

@@ -0,0 +1,15 @@
+export const CLI_VERSION = "0.1.0-test.1";
+export const OUTPUT_SCHEMA_VERSION = "1.0";
+export const CONFIG_SCHEMA_VERSION = "1.0";
+export const MIN_NODE_MAJOR = 22;
+export const P1_CAPABILITY_SCOPES = [
+    "profile:read",
+    "capabilities:read",
+    "employees:read",
+    "employees:chat",
+    "assets:read",
+    "metrics:read",
+    "alarms:read",
+    "incidents:analyze",
+    "inspections:run-readonly",
+];

package/dist/credentials.js

@@ -0,0 +1,198 @@
+import { spawn } from "node:child_process";
+const MAX_CREDENTIAL_LENGTH = 4096;
+export class CredentialStoreError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.name = "CredentialStoreError";
+        this.code = code;
+    }
+}
+function validSecret(value) {
+    return typeof value === "string" && value.length > 0 && value.length <= MAX_CREDENTIAL_LENGTH && !/[\u0000\r\n]/.test(value);
+}
+function safeProfile(profile) {
+    if (!/^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/.test(profile)) {
+        throw new CredentialStoreError("CREDENTIAL_STORE_ERROR", "Profile name is invalid");
+    }
+    return profile;
+}
+/** Spawn a fixed executable without a shell and without putting secret input in argv/env. */
+export const processCommandRunner = (command, args, options = {}) => new Promise((resolve, reject) => {
+    let child;
+    try {
+        const allowedEnvironmentKeys = new Set([
+            "HOME",
+            "PATH",
+            "LANG",
+            "LC_ALL",
+            "LC_CTYPE",
+            "DBUS_SESSION_BUS_ADDRESS",
+            "XDG_RUNTIME_DIR",
+            "XDG_CONFIG_HOME",
+            "DISPLAY",
+        ]);
+        const environment = Object.fromEntries(Object.entries(process.env).filter(([key]) => allowedEnvironmentKeys.has(key) || key.startsWith("LC_")));
+        child = spawn(command, [...args], {
+            shell: false,
+            stdio: ["pipe", "pipe", "pipe"],
+            env: environment,
+        });
+    }
+    catch {
+        reject(new CredentialStoreError("CREDENTIAL_STORE_UNAVAILABLE", "System credential store is unavailable"));
+        return;
+    }
+    let stdout = "";
+    let stderr = "";
+    let timer;
+    const finish = (result) => {
+        if (timer)
+            clearTimeout(timer);
+        resolve(result);
+    };
+    child.stdout.on("data", (chunk) => {
+        stdout += chunk.toString();
+        if (stdout.length > 16384)
+            child.kill();
+    });
+    child.stderr.on("data", (chunk) => {
+        stderr += chunk.toString();
+        if (stderr.length > 16384)
+            child.kill();
+    });
+    child.once("error", () => {
+        if (timer)
+            clearTimeout(timer);
+        reject(new CredentialStoreError("CREDENTIAL_STORE_UNAVAILABLE", "System credential store is unavailable"));
+    });
+    child.once("close", (code) => finish({ code: code ?? 1, stdout, stderr }));
+    if (options.timeoutMs) {
+        timer = setTimeout(() => {
+            child.kill();
+            reject(new CredentialStoreError("CREDENTIAL_STORE_UNAVAILABLE", "System credential store timed out"));
+        }, options.timeoutMs);
+    }
+    if (options.input !== undefined)
+        child.stdin.write(options.input);
+    child.stdin.end();
+});
+function missingResult(result) {
+    return result.code !== 0 && !result.stdout.trim() && !result.stderr.trim();
+}
+/** OS-backed secret store. There is deliberately no plaintext-file fallback. */
+export class SecureCredentialStore {
+    service;
+    account;
+    platform;
+    runner;
+    constructor(profile, options = {}) {
+        const safe = safeProfile(profile);
+        this.service = "zhihu-pilot-cli";
+        this.account = safe;
+        this.platform = options.platform ?? process.platform;
+        this.runner = options.runner ?? processCommandRunner;
+    }
+    command() {
+        if (this.platform === "darwin") {
+            return {
+                executable: "/usr/bin/security",
+                readArgs: ["find-generic-password", "-s", this.service, "-a", this.account, "-w"],
+                // -w intentionally remains the final argument; the secret is sent via stdin.
+                writeArgs: ["add-generic-password", "-U", "-s", this.service, "-a", this.account, "-w"],
+                deleteArgs: ["delete-generic-password", "-s", this.service, "-a", this.account],
+                checkArgs: ["list-keychains"],
+            };
+        }
+        if (this.platform === "linux") {
+            return {
+                executable: "/usr/bin/secret-tool",
+                readArgs: ["lookup", "service", this.service, "account", this.account],
+                writeArgs: ["store", "--label", "Zhihu Pilot CLI", "service", this.service, "account", this.account],
+                deleteArgs: ["clear", "service", this.service, "account", this.account],
+                checkArgs: ["--version"],
+            };
+        }
+        throw new CredentialStoreError("CREDENTIAL_STORE_UNAVAILABLE", "This operating system has no supported credential store");
+    }
+    async available() {
+        try {
+            const command = this.command();
+            const result = await this.runner(command.executable, command.checkArgs, { timeoutMs: 5000 });
+            if (result.code !== 0)
+                throw new CredentialStoreError("CREDENTIAL_STORE_UNAVAILABLE", "System credential store is unavailable");
+            return true;
+        }
+        catch (error) {
+            if (error instanceof CredentialStoreError)
+                throw error;
+            throw new CredentialStoreError("CREDENTIAL_STORE_UNAVAILABLE", "System credential store is unavailable");
+        }
+    }
+    async get() {
+        try {
+            const command = this.command();
+            const result = await this.runner(command.executable, command.readArgs, { timeoutMs: 5000 });
+            if (result.code !== 0) {
+                const diagnostic = result.stderr.toLowerCase();
+                if (missingResult(result) || diagnostic.includes("could not be found") || diagnostic.includes("no such secret") || diagnostic.includes("not found"))
+                    return null;
+                throw new CredentialStoreError("CREDENTIAL_STORE_ERROR", "Unable to read system credential");
+            }
+            const credential = result.stdout.trim();
+            if (!credential)
+                return null;
+            if (!validSecret(credential))
+                throw new CredentialStoreError("CREDENTIAL_STORE_ERROR", "Stored credential is invalid");
+            return credential;
+        }
+        catch (error) {
+            if (error instanceof CredentialStoreError)
+                throw error;
+            throw new CredentialStoreError("CREDENTIAL_STORE_ERROR", "Unable to read system credential");
+        }
+    }
+    async set(credential) {
+        if (!validSecret(credential))
+            throw new CredentialStoreError("CREDENTIAL_STORE_ERROR", "Credential is invalid");
+        try {
+            const command = this.command();
+            const result = await this.runner(command.executable, command.writeArgs, {
+                input: `${credential}\n`,
+                timeoutMs: 5000,
+            });
+            if (result.code !== 0)
+                throw new CredentialStoreError("CREDENTIAL_STORE_ERROR", "Unable to write system credential");
+        }
+        catch (error) {
+            if (error instanceof CredentialStoreError)
+                throw error;
+            throw new CredentialStoreError("CREDENTIAL_STORE_ERROR", "Unable to write system credential");
+        }
+    }
+    async delete() {
+        try {
+            const command = this.command();
+            const result = await this.runner(command.executable, command.deleteArgs, { timeoutMs: 5000 });
+            const diagnostic = result.stderr.toLowerCase();
+            if (result.code !== 0 && !missingResult(result) && !diagnostic.includes("could not be found") && !diagnostic.includes("no such secret") && !diagnostic.includes("not found")) {
+                throw new CredentialStoreError("CREDENTIAL_STORE_ERROR", "Unable to delete system credential");
+            }
+        }
+        catch (error) {
+            if (error instanceof CredentialStoreError)
+                throw error;
+            throw new CredentialStoreError("CREDENTIAL_STORE_ERROR", "Unable to delete system credential");
+        }
+    }
+    async read() {
+        return this.get();
+    }
+    async write(credential) {
+        return this.set(credential);
+    }
+    async remove() {
+        return this.delete();
+    }
+}
+export { SecureCredentialStore as OsCredentialStore };