agent-sin 0.1.0

package/dist/core/skill-scaffold.js

@@ -0,0 +1,256 @@
+import { copyFile, mkdir, readdir, readFile, stat, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { loadModels } from "./config.js";
+import { loadSkillManifest, resolveSkillEntryPath } from "./skill-registry.js";
+import { l } from "./i18n.js";
+export async function scaffoldSkill(config, options) {
+    validateSkillId(options.id);
+    const templateDir = options.templateRoot
+        ? path.join(options.templateRoot, templateDirName(options.runtime))
+        : resolveDefaultTemplateDir(options.runtime);
+    await assertTemplateExists(templateDir);
+    const target = path.join(config.skills_dir, options.id);
+    if (await exists(target)) {
+        throw new Error(l(`Skill directory already exists: ${target}`, `スキルディレクトリが既に存在します: ${target}`));
+    }
+    await mkdir(target, { recursive: true });
+    const written = [];
+    await copyTemplate(templateDir, target, target, written);
+    await rewriteManifest(path.join(target, "skill.yaml"), {
+        ...options,
+        name: options.name || titleizeSkillId(options.id),
+    });
+    const entryName = options.runtime === "python" ? "main.py" : "main.ts";
+    return {
+        skill_id: options.id,
+        skill_dir: target,
+        manifest_path: path.join(target, "skill.yaml"),
+        entry_path: path.join(target, entryName),
+        files: written.sort(),
+        runtime: options.runtime,
+    };
+}
+export function validateSkillId(id) {
+    if (!id) {
+        throw new Error(l("Skill id is required", "Skill id は必須です"));
+    }
+    if (!/^[a-z][a-z0-9-]*$/.test(id)) {
+        throw new Error(l(`Invalid skill id: '${id}' (must be kebab-case, start with a lowercase letter, allow [a-z0-9-])`, `skill id が不正です: '${id}' (kebab-case、小文字開始、[a-z0-9-] のみ使用可)`));
+    }
+    if (id.length > 64) {
+        throw new Error(l(`Skill id is too long (max 64 chars): ${id}`, `Skill id が長すぎます (最大64文字): ${id}`));
+    }
+}
+function templateDirName(runtime) {
+    return runtime === "python" ? "skill-python" : "skill-typescript";
+}
+function titleizeSkillId(id) {
+    return id
+        .split("-")
+        .filter((part) => part.length > 0)
+        .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+        .join(" ");
+}
+function resolveDefaultTemplateDir(runtime) {
+    const here = path.dirname(fileURLToPath(import.meta.url));
+    const root = path.resolve(here, "../..");
+    return path.join(root, "templates", templateDirName(runtime));
+}
+async function assertTemplateExists(dir) {
+    try {
+        const info = await stat(dir);
+        if (!info.isDirectory()) {
+            throw new Error(l(`Template path is not a directory: ${dir}`, `テンプレートパスがディレクトリではありません: ${dir}`));
+        }
+    }
+    catch (error) {
+        if (error instanceof Error && error.message.startsWith("Template path")) {
+            throw error;
+        }
+        throw new Error(l(`Skill template not found: ${dir}`, `スキルテンプレートが見つかりません: ${dir}`));
+    }
+}
+async function copyTemplate(templateDir, targetRoot, current, written) {
+    const sourceCurrent = current === targetRoot ? templateDir : current.replace(targetRoot, templateDir);
+    for (const entry of await readdir(sourceCurrent, { withFileTypes: true })) {
+        if (entry.name === "node_modules" || entry.name.startsWith(".")) {
+            continue;
+        }
+        const sourcePath = path.join(sourceCurrent, entry.name);
+        const targetPath = path.join(current, entry.name);
+        if (entry.isDirectory()) {
+            await mkdir(targetPath, { recursive: true });
+            await copyTemplate(templateDir, targetRoot, targetPath, written);
+            continue;
+        }
+        if (entry.isFile()) {
+            await copyFile(sourcePath, targetPath);
+            written.push(path.relative(targetRoot, targetPath));
+        }
+    }
+}
+async function rewriteManifest(file, options) {
+    const raw = await readFile(file, "utf8");
+    let next = replaceLine(raw, /^id:\s+.+$/m, `id: ${options.id}`);
+    if (options.name) {
+        next = replaceLine(next, /^name:\s+.+$/m, `name: ${options.name}`);
+    }
+    if (options.description) {
+        next = replaceLine(next, /^description:\s+.+$/m, `description: ${options.description}`);
+    }
+    next = next.replace(/^(\s*namespace:)\s+.+$/m, `$1 ${options.id}`);
+    await writeFile(file, next, "utf8");
+}
+function replaceLine(content, pattern, replacement) {
+    if (pattern.test(content)) {
+        return content.replace(pattern, replacement);
+    }
+    return `${replacement}\n${content}`;
+}
+async function exists(target) {
+    try {
+        await stat(target);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function validateInstalledSkill(config, skillId) {
+    return validateSkillDirectory(path.join(config.skills_dir, skillId), skillId, {
+        knownModelIds: await loadKnownModelIds(config),
+    });
+}
+export async function validateSkillDirectory(skillDir, skillId, options = {}) {
+    const errors = [];
+    const warnings = [];
+    if (!(await exists(skillDir))) {
+        errors.push(l(`Skill directory not found: ${skillDir}`, `スキルディレクトリが見つかりません: ${skillDir}`));
+        return { ok: false, skill_dir: skillDir, errors, warnings };
+    }
+    let manifest;
+    try {
+        manifest = await loadSkillManifest(skillDir);
+    }
+    catch (error) {
+        errors.push(error instanceof Error ? error.message : String(error));
+        return { ok: false, skill_dir: skillDir, errors, warnings };
+    }
+    if (manifest.id !== skillId) {
+        errors.push(l(`Manifest id "${manifest.id}" does not match directory name "${skillId}"`, `Manifest id "${manifest.id}" がディレクトリ名 "${skillId}" と一致しません`));
+    }
+    if (!manifest.description || manifest.description.trim().length === 0) {
+        warnings.push(l("description is empty (chat mode uses it to decide when to call this skill)", "description が空です (chat mode がこのスキルを呼ぶ判断に使います)"));
+    }
+    const phrases = manifest.invocation?.phrases?.filter((phrase) => typeof phrase === "string" && phrase.trim()) || [];
+    const hasCommand = typeof manifest.invocation?.command === "string" && manifest.invocation.command.trim().length > 0;
+    if (!hasCommand && phrases.length === 0) {
+        errors.push(l("invocation.phrases is required so chat mode can call this skill (or set invocation.command).", "invocation.phrases は必須です。チャットからスキルを呼ぶための代表的な発話を3個以上書いてください (または invocation.command を設定)。"));
+    }
+    let entryPath = "";
+    try {
+        entryPath = await resolveSkillEntryPath(manifest);
+        if (manifest.runtime === "python" && !manifest.entry.endsWith(".py")) {
+            warnings.push(l(`runtime=python but entry "${manifest.entry}" does not end with .py`, `runtime=python ですが entry "${manifest.entry}" が .py で終わっていません`));
+        }
+        else if (manifest.runtime === "typescript" && !/\.(ts|tsx|mts|cts|js|mjs|cjs)$/.test(manifest.entry)) {
+            warnings.push(l(`runtime=typescript but entry "${manifest.entry}" has unsupported extension`, `runtime=typescript ですが entry "${manifest.entry}" の拡張子が未対応です`));
+        }
+    }
+    catch (error) {
+        errors.push(error instanceof Error ? error.message : String(error));
+    }
+    validateRequiredEnvConventions(manifest, errors);
+    for (const output of manifest.outputs) {
+        if (!output.id) {
+            errors.push(l("outputs[].id is required", "outputs[].id は必須です"));
+        }
+        if (output.type !== "markdown" && output.type !== "json") {
+            errors.push(l(`outputs[${output.id}].type must be 'markdown' or 'json' (got '${output.type}')`, `outputs[${output.id}].type は 'markdown' または 'json' である必要があります ('${output.type}')`));
+        }
+        if (!output.path) {
+            warnings.push(l(`outputs[${output.id}].path is empty`, `outputs[${output.id}].path が空です`));
+        }
+        if (!output.filename) {
+            warnings.push(l(`outputs[${output.id}].filename is empty`, `outputs[${output.id}].filename が空です`));
+        }
+    }
+    if (manifest.memory && !manifest.memory.namespace) {
+        errors.push(l("memory.namespace is required when memory section is present", "memory セクションがある場合 memory.namespace は必須です"));
+    }
+    if (manifest.ai_steps) {
+        const seen = new Set();
+        for (const step of manifest.ai_steps) {
+            if (!step.id) {
+                errors.push(l("ai_steps[].id is required", "ai_steps[].id は必須です"));
+                continue;
+            }
+            if (seen.has(step.id)) {
+                errors.push(l(`ai_steps[].id duplicated: ${step.id}`, `ai_steps[].id が重複しています: ${step.id}`));
+            }
+            seen.add(step.id);
+            if (!step.model) {
+                warnings.push(l(`ai_steps[${step.id}].model is empty`, `ai_steps[${step.id}].model が空です`));
+            }
+            else if (options.knownModelIds && !options.knownModelIds.has(step.model)) {
+                errors.push(l(`ai_steps[${step.id}].model references unknown model id "${step.model}"`, `ai_steps[${step.id}].model が不明な model id "${step.model}" を参照しています`));
+            }
+            if (!step.purpose) {
+                warnings.push(l(`ai_steps[${step.id}].purpose is empty (helps the model behave correctly)`, `ai_steps[${step.id}].purpose が空です (モデルの挙動安定に役立ちます)`));
+            }
+        }
+    }
+    if (entryPath) {
+        await validateSourceConventions(entryPath, errors);
+    }
+    return { ok: errors.length === 0, manifest, skill_dir: skillDir, errors, warnings };
+}
+export async function loadKnownModelIds(config) {
+    try {
+        const models = await loadModels(config.workspace);
+        const ids = new Set(Object.keys(models.models || {}));
+        for (const role of Object.keys(models.roles || {})) {
+            ids.add(role);
+        }
+        return ids;
+    }
+    catch {
+        return new Set();
+    }
+}
+function validateRequiredEnvConventions(manifest, errors) {
+    for (const entry of manifest.required_env || []) {
+        const name = entry.name.trim();
+        if (/^AGENT_SIN_/i.test(name)) {
+            errors.push(l(`required_env "${name}" is reserved for agent-sin runtime settings`, `required_env "${name}" は agent-sin 本体設定のため予約されています`));
+        }
+        if (name === "DISCORD_WEBHOOK_URL") {
+            errors.push(l('required_env "DISCORD_WEBHOOK_URL" must not be used; call agent-sin notify for Discord notifications', 'required_env "DISCORD_WEBHOOK_URL" は使えません。Discord通知は agent-sin notify を使ってください'));
+        }
+        if (name === "TELEGRAM_BOT_TOKEN") {
+            errors.push(l('required_env "TELEGRAM_BOT_TOKEN" must not be used; call agent-sin notify for Telegram notifications', 'required_env "TELEGRAM_BOT_TOKEN" は使えません。Telegram通知は agent-sin notify を使ってください'));
+        }
+    }
+}
+async function validateSourceConventions(entryPath, errors) {
+    let source = "";
+    try {
+        source = await readFile(entryPath, "utf8");
+    }
+    catch {
+        return;
+    }
+    if (/\bDISCORD_WEBHOOK_URL\b/.test(source)) {
+        errors.push(l('entry file must not read DISCORD_WEBHOOK_URL; use "agent-sin notify --channel discord"', 'entry file は DISCORD_WEBHOOK_URL を読んではいけません。"agent-sin notify --channel discord" を使ってください'));
+    }
+    if (/discord\.com\/api\/webhooks/i.test(source)) {
+        errors.push(l('entry file must not post directly to Discord webhooks; use "agent-sin notify --channel discord"', 'entry file は Discord webhook へ直接POSTしてはいけません。"agent-sin notify --channel discord" を使ってください'));
+    }
+    if (/\bTELEGRAM_BOT_TOKEN\b/.test(source)) {
+        errors.push(l('entry file must not read TELEGRAM_BOT_TOKEN; use "agent-sin notify --channel telegram"', 'entry file は TELEGRAM_BOT_TOKEN を読んではいけません。"agent-sin notify --channel telegram" を使ってください'));
+    }
+    if (/api\.telegram\.org\/bot/i.test(source)) {
+        errors.push(l('entry file must not post directly to Telegram Bot API; use "agent-sin notify --channel telegram"', 'entry file は Telegram Bot API へ直接POSTしてはいけません。"agent-sin notify --channel telegram" を使ってください'));
+    }
+}

package/dist/core/skill-settings.d.ts

@@ -0,0 +1,11 @@
+export interface SkillSettings {
+    /** Skill ids the user has explicitly disabled. */
+    disabled: Set<string>;
+}
+export declare function skillSettingsPath(workspace: string): string;
+export declare function loadSkillSettings(workspace: string): Promise<SkillSettings>;
+export declare function saveSkillSettings(workspace: string, settings: SkillSettings): Promise<string>;
+export declare function setSkillEnabled(workspace: string, skillId: string, enabled: boolean): Promise<{
+    changed: boolean;
+    settings: SkillSettings;
+}>;

package/dist/core/skill-settings.js

@@ -0,0 +1,63 @@
+import { mkdir, readFile, stat, writeFile } from "node:fs/promises";
+import path from "node:path";
+import YAML from "yaml";
+export function skillSettingsPath(workspace) {
+    return path.join(workspace, "skill-settings.yaml");
+}
+export async function loadSkillSettings(workspace) {
+    const file = skillSettingsPath(workspace);
+    try {
+        await stat(file);
+    }
+    catch {
+        return { disabled: new Set() };
+    }
+    let raw;
+    try {
+        raw = await readFile(file, "utf8");
+    }
+    catch {
+        return { disabled: new Set() };
+    }
+    const parsed = (raw.trim() ? YAML.parse(raw) : null) || {};
+    const disabled = new Set();
+    const rawDisabled = parsed.disabled;
+    if (Array.isArray(rawDisabled)) {
+        for (const id of rawDisabled) {
+            if (typeof id === "string" && id.trim().length > 0) {
+                disabled.add(id.trim());
+            }
+        }
+    }
+    return { disabled };
+}
+export async function saveSkillSettings(workspace, settings) {
+    const file = skillSettingsPath(workspace);
+    await mkdir(path.dirname(file), { recursive: true });
+    const disabled = Array.from(settings.disabled).sort();
+    const payload = {};
+    if (disabled.length > 0) {
+        payload.disabled = disabled;
+    }
+    const content = disabled.length === 0 ? "disabled: []\n" : YAML.stringify(payload);
+    await writeFile(file, content, "utf8");
+    return file;
+}
+export async function setSkillEnabled(workspace, skillId, enabled) {
+    const settings = await loadSkillSettings(workspace);
+    const wasDisabled = settings.disabled.has(skillId);
+    if (enabled) {
+        if (!wasDisabled) {
+            return { changed: false, settings };
+        }
+        settings.disabled.delete(skillId);
+    }
+    else {
+        if (wasDisabled) {
+            return { changed: false, settings };
+        }
+        settings.disabled.add(skillId);
+    }
+    await saveSkillSettings(workspace, settings);
+    return { changed: true, settings };
+}

package/dist/core/transfer.d.ts

@@ -0,0 +1,31 @@
+export interface ExportOptions {
+    workspace?: string;
+    outFile?: string;
+    includeSecrets?: boolean;
+    includeLogs?: boolean;
+    includeIndex?: boolean;
+}
+export interface ExportResult {
+    archivePath: string;
+    byteSize: number;
+    includedItems: string[];
+    warnings: string[];
+}
+export interface ImportOptions {
+    archivePath: string;
+    workspace?: string;
+    dryRun?: boolean;
+    backup?: boolean;
+}
+export interface ImportResult {
+    workspace: string;
+    archivePath: string;
+    entries: string[];
+    backupPath?: string;
+    dryRun: boolean;
+}
+export declare function exportWorkspace(options?: ExportOptions): Promise<ExportResult>;
+export declare function listArchiveEntries(archivePath: string): Promise<string[]>;
+export declare function importWorkspace(options: ImportOptions): Promise<ImportResult>;
+export declare function pathExists(file: string): Promise<boolean>;
+export declare function formatBytes(bytes: number): string;

package/dist/core/transfer.js

@@ -0,0 +1,270 @@
+import { spawn } from "node:child_process";
+import { copyFile, lstat, mkdir, mkdtemp, readdir, rename, rm, stat } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { defaultWorkspace } from "./config.js";
+import { l } from "./i18n.js";
+const DEFAULT_INCLUDE = [
+    ".env",
+    "config.toml",
+    "models.yaml",
+    "skill-settings.yaml",
+    "skills",
+    "memory",
+    "notes",
+    "schedules.yaml",
+    "discord",
+    "telegram",
+    "logs",
+    "index",
+];
+const ALWAYS_EXCLUDE = [".venv", "node_modules", ".DS_Store"];
+export async function exportWorkspace(options = {}) {
+    const workspace = options.workspace || defaultWorkspace();
+    if (!(await pathExists(workspace))) {
+        throw new Error(l(`Workspace not found: ${workspace}`, `ワークスペースが見つかりません: ${workspace}`));
+    }
+    const include = [...DEFAULT_INCLUDE];
+    if (options.includeSecrets && !include.includes(".env"))
+        include.push(".env");
+    if (options.includeLogs && !include.includes("logs"))
+        include.push("logs");
+    if (options.includeIndex && !include.includes("index"))
+        include.push("index");
+    const present = [];
+    const missing = [];
+    for (const item of include) {
+        if (await pathExists(path.join(workspace, item))) {
+            present.push(item);
+        }
+        else {
+            missing.push(item);
+        }
+    }
+    if (present.length === 0) {
+        throw new Error(l("No transferable workspace data was found.", "ワークスペースに移行可能なデータが見つかりません。"));
+    }
+    const archivePath = path.resolve(options.outFile || defaultArchivePath());
+    await mkdir(path.dirname(archivePath), { recursive: true });
+    const args = ["-czf", archivePath, "-C", workspace];
+    for (const exc of ALWAYS_EXCLUDE) {
+        args.push(`--exclude=${exc}`);
+    }
+    args.push(...present);
+    await runTar(args);
+    const stats = await stat(archivePath);
+    return {
+        archivePath,
+        byteSize: stats.size,
+        includedItems: present,
+        warnings: missing.length > 0 ? [l(`Missing items: ${missing.join(", ")}`, `存在しなかった項目: ${missing.join(", ")}`)] : [],
+    };
+}
+export async function listArchiveEntries(archivePath) {
+    if (!(await pathExists(archivePath))) {
+        throw new Error(l(`Archive not found: ${archivePath}`, `アーカイブが見つかりません: ${archivePath}`));
+    }
+    const entries = await listArchiveMetadata(path.resolve(archivePath));
+    assertSafeArchiveEntries(entries);
+    return entries.map((entry) => entry.path);
+}
+export async function importWorkspace(options) {
+    if (!(await pathExists(options.archivePath))) {
+        throw new Error(l(`Archive not found: ${options.archivePath}`, `アーカイブが見つかりません: ${options.archivePath}`));
+    }
+    const archivePath = path.resolve(options.archivePath);
+    const workspace = options.workspace || defaultWorkspace();
+    const archiveEntries = await listArchiveMetadata(archivePath);
+    assertSafeArchiveEntries(archiveEntries);
+    const entries = archiveEntries.map((entry) => entry.path);
+    if (options.dryRun) {
+        return { workspace, archivePath, entries, dryRun: true };
+    }
+    const tempRoot = await mkdtemp(path.join(os.tmpdir(), "agent-sin-import-"));
+    try {
+        await runTar(["-xzf", archivePath, "-C", tempRoot]);
+        await assertExtractedTreeSafe(tempRoot);
+        let backupPath;
+        if ((options.backup ?? true) && (await pathExists(workspace))) {
+            backupPath = await backupExistingWorkspace(workspace);
+        }
+        await mkdir(workspace, { recursive: true });
+        await copySafeTree(tempRoot, workspace);
+        return { workspace, archivePath, entries, backupPath, dryRun: false };
+    }
+    finally {
+        await rm(tempRoot, { recursive: true, force: true });
+    }
+}
+async function backupExistingWorkspace(workspace) {
+    const ts = formatTimestamp(new Date());
+    const backupPath = `${workspace}.bak-${ts}`;
+    await rename(workspace, backupPath);
+    return backupPath;
+}
+function defaultArchivePath() {
+    const ts = formatTimestamp(new Date());
+    return path.resolve(process.cwd(), `agent-sin-backup-${ts}.tar.gz`);
+}
+function formatTimestamp(date) {
+    const yyyy = date.getFullYear();
+    const mm = String(date.getMonth() + 1).padStart(2, "0");
+    const dd = String(date.getDate()).padStart(2, "0");
+    const hh = String(date.getHours()).padStart(2, "0");
+    const mi = String(date.getMinutes()).padStart(2, "0");
+    const ss = String(date.getSeconds()).padStart(2, "0");
+    return `${yyyy}${mm}${dd}-${hh}${mi}${ss}`;
+}
+export async function pathExists(file) {
+    try {
+        await stat(file);
+        return true;
+    }
+    catch (error) {
+        if (isMissingFile(error))
+            return false;
+        throw error;
+    }
+}
+function isMissingFile(error) {
+    return (typeof error === "object" &&
+        error !== null &&
+        "code" in error &&
+        error.code === "ENOENT");
+}
+function runTar(args) {
+    return new Promise((resolve, reject) => {
+        const child = spawn("tar", args, { stdio: ["ignore", "ignore", "pipe"] });
+        let stderr = "";
+        child.stderr.on("data", (chunk) => {
+            stderr += chunk.toString();
+        });
+        child.once("error", (error) => {
+            if (error.code === "ENOENT") {
+                reject(new Error(l("tar command not found. Install tar first.", "tar コマンドが見つかりません。tar をインストールしてください。")));
+            }
+            else {
+                reject(error);
+            }
+        });
+        child.once("close", (code) => {
+            if (code === 0) {
+                resolve();
+            }
+            else {
+                reject(new Error(l(`tar failed (code ${code}): ${stderr.trim()}`, `tar が失敗しました (code ${code}): ${stderr.trim()}`)));
+            }
+        });
+    });
+}
+function runTarCapture(args) {
+    return new Promise((resolve, reject) => {
+        const child = spawn("tar", args, { stdio: ["ignore", "pipe", "pipe"] });
+        let stdout = "";
+        let stderr = "";
+        child.stdout.on("data", (chunk) => {
+            stdout += chunk.toString();
+        });
+        child.stderr.on("data", (chunk) => {
+            stderr += chunk.toString();
+        });
+        child.once("error", (error) => {
+            if (error.code === "ENOENT") {
+                reject(new Error(l("tar command not found. Install tar first.", "tar コマンドが見つかりません。tar をインストールしてください。")));
+            }
+            else {
+                reject(error);
+            }
+        });
+        child.once("close", (code) => {
+            if (code === 0) {
+                resolve(stdout);
+            }
+            else {
+                reject(new Error(l(`tar failed (code ${code}): ${stderr.trim()}`, `tar が失敗しました (code ${code}): ${stderr.trim()}`)));
+            }
+        });
+    });
+}
+async function listArchiveMetadata(archivePath) {
+    const namesOut = await runTarCapture(["-tzf", archivePath]);
+    const names = namesOut
+        .split("\n")
+        .map((line) => line.trim())
+        .filter((line) => line.length > 0);
+    const verboseOut = await runTarCapture(["-tvzf", archivePath]);
+    const types = verboseOut
+        .split("\n")
+        .map((line) => line.trimStart())
+        .filter((line) => line.length > 0)
+        .map((line) => line.charAt(0));
+    if (types.length !== names.length) {
+        throw new Error(l("The archive could not be inspected safely.", "アーカイブの内容を安全に検査できませんでした。"));
+    }
+    return names.map((entryPath, index) => ({ path: entryPath, type: types[index] }));
+}
+function assertSafeArchiveEntries(entries) {
+    for (const entry of entries) {
+        const name = entry.path;
+        if (!name || name.includes("\0")) {
+            throw new Error(l("The archive contains an invalid path.", "アーカイブに不正なパスが含まれています。"));
+        }
+        if (name.includes("\\") || path.isAbsolute(name) || /^[A-Za-z]:/.test(name)) {
+            throw new Error(l(`The archive contains a disallowed path: ${name}`, `アーカイブに許可されないパスが含まれています: ${name}`));
+        }
+        const normalized = path.posix.normalize(name);
+        if (normalized === "." || normalized === ".." || normalized.startsWith("../") || name.split("/").includes("..")) {
+            throw new Error(l(`The archive contains a path outside the workspace: ${name}`, `アーカイブにワークスペース外へ出るパスが含まれています: ${name}`));
+        }
+        if (entry.type !== "-" && entry.type !== "d") {
+            throw new Error(l(`The archive contains an entry that is not a regular file or directory: ${name}`, `アーカイブに通常ファイル/ディレクトリ以外が含まれています: ${name}`));
+        }
+    }
+}
+async function assertExtractedTreeSafe(root) {
+    async function walk(dir) {
+        for (const entry of await readdir(dir)) {
+            const full = path.join(dir, entry);
+            const info = await lstat(full);
+            if (info.isSymbolicLink()) {
+                throw new Error(l(`The archive contains a symbolic link: ${entry}`, `アーカイブにシンボリックリンクが含まれています: ${entry}`));
+            }
+            if (info.isDirectory()) {
+                await walk(full);
+                continue;
+            }
+            if (!info.isFile()) {
+                throw new Error(l(`The archive contains an entry that is not a regular file or directory: ${entry}`, `アーカイブに通常ファイル/ディレクトリ以外が含まれています: ${entry}`));
+            }
+        }
+    }
+    await walk(root);
+}
+async function copySafeTree(source, target) {
+    await mkdir(target, { recursive: true });
+    for (const entry of await readdir(source, { withFileTypes: true })) {
+        const src = path.join(source, entry.name);
+        const dest = path.join(target, entry.name);
+        if (entry.isDirectory()) {
+            await copySafeTree(src, dest);
+            continue;
+        }
+        if (!entry.isFile()) {
+            throw new Error(l(`Cannot restore this file type: ${entry.name}`, `復元できないファイル種別です: ${entry.name}`));
+        }
+        await mkdir(path.dirname(dest), { recursive: true });
+        await copyFile(src, dest);
+    }
+}
+export function formatBytes(bytes) {
+    if (bytes < 1024)
+        return `${bytes} B`;
+    const units = ["KB", "MB", "GB"];
+    let value = bytes / 1024;
+    for (const unit of units) {
+        if (value < 1024)
+            return `${value.toFixed(1)} ${unit}`;
+        value /= 1024;
+    }
+    return `${value.toFixed(1)} TB`;
+}

package/dist/core/update-notifier.d.ts

@@ -0,0 +1,2 @@
+export declare function scheduleUpdateCheck(workspace?: string): void;
+export declare function consumeUpdateBanner(workspace?: string): Promise<string | null>;