jishushell 0.6.18 → 0.7.3

package/dist/services/integrations/immich/immich-shim.js

@@ -0,0 +1,439 @@
+import { IMMICH_DEFAULT_PHOTO_LIBRARY_NAME, IMMICH_DEFAULT_PHOTO_LIBRARY_PATH, } from "./photo-library.js";
+export const IMMICH_MCP_SHIM_VERSION = "0.3.0";
+export const IMMICH_SHIM_SECRET_FILENAME = "secret.json";
+export { IMMICH_DEFAULT_PHOTO_LIBRARY_NAME, IMMICH_DEFAULT_PHOTO_LIBRARY_PATH, } from "./photo-library.js";
+export const IMMICH_PUBLIC_MCP_TOOL_NAMES = [
+    "ping",
+    "get_library_summary",
+    "get_photo_library_status",
+    "scan_photo_library",
+    "create_photo_upload_session",
+    "get_asset_info",
+    "list_assets",
+    "search_metadata",
+    "search_smart",
+    "get_map_markers",
+    "list_albums",
+    "get_album",
+    "create_album",
+    "update_album",
+    "delete_album",
+    "list_tags",
+    "get_tag",
+    "create_tag",
+    "update_tag",
+    "delete_tag",
+    "generate_review_gallery",
+    "restore_assets",
+    "get_duplicates",
+    "list_people",
+    "search_people",
+    "get_person",
+    "get_asset_faces",
+];
+export const IMMICH_MCP_SHIM_SOURCE = `#!/usr/bin/env node
+// jishushell-immich-shim — generated, do not edit by hand.
+// Source: src/services/integrations/immich/immich-shim.ts
+
+const fs = require("node:fs");
+const path = require("node:path");
+const readline = require("node:readline");
+
+const VERSION = ${JSON.stringify(IMMICH_MCP_SHIM_VERSION)};
+const SECRET_FILENAME = ${JSON.stringify(IMMICH_SHIM_SECRET_FILENAME)};
+const BASE_URL_LIT = "__JS_IMMICH_BASE_URL__";
+const CORE_URL_LIT = "__JS_CORE_URL__";
+const INSTANCE_ID_LIT = "__JS_INSTANCE_ID__";
+const PHOTO_LIBRARY_ENABLED = __JS_IMMICH_PHOTO_LIBRARY_ENABLED__;
+const PHOTO_LIBRARY_NAME = ${JSON.stringify(IMMICH_DEFAULT_PHOTO_LIBRARY_NAME)};
+const PHOTO_LIBRARY_PATH = ${JSON.stringify(IMMICH_DEFAULT_PHOTO_LIBRARY_PATH)};
+
+const BASE_URL = (BASE_URL_LIT.startsWith("__JS_") ? (process.env.IMMICH_BASE_URL || "") : BASE_URL_LIT).replace(/\\/+$/, "");
+const CORE_URL = (CORE_URL_LIT.startsWith("__JS_") ? (process.env.JISHUSHELL_CORE_URL || "") : CORE_URL_LIT).replace(/\\/+$/, "");
+const INSTANCE_ID = INSTANCE_ID_LIT.startsWith("__JS_") ? (process.env.JISHUSHELL_INSTANCE_ID || "") : INSTANCE_ID_LIT;
+
+function loadSecret() {
+  try {
+    const secretPath = path.join(__dirname, SECRET_FILENAME);
+    const raw = fs.readFileSync(secretPath, "utf-8");
+    const json = JSON.parse(raw);
+    return json && typeof json === "object" ? json : {};
+  } catch (_) {}
+  return {};
+}
+
+function loadApiKey() {
+  const secret = loadSecret();
+  if (typeof secret.apiKey === "string" && secret.apiKey.trim()) return secret.apiKey.trim();
+  return process.env.IMMICH_API_KEY || process.env.JISHUSHELL_DEV_IMMICH_API_KEY || "";
+}
+
+function loadInternalToken() {
+  const secret = loadSecret();
+  if (typeof secret.internalToken === "string" && secret.internalToken.trim()) return secret.internalToken.trim();
+  return process.env.JISHUSHELL_INTERNAL_TOKEN || "";
+}
+
+function envCheck() {
+  const missing = [];
+  if (!BASE_URL) missing.push("IMMICH_BASE_URL");
+  if (!loadApiKey()) missing.push("IMMICH_API_KEY");
+  if (missing.length) throw new Error("immich-shim: missing config: " + missing.join(", "));
+}
+
+async function coreSend(method, requestPath, body) {
+  const internalToken = loadInternalToken();
+  if (!CORE_URL || !internalToken || !INSTANCE_ID) {
+    throw new Error("Core-backed Immich interaction is unavailable because the Core connection is missing");
+  }
+  const response = await fetch(CORE_URL + requestPath, {
+    method,
+    headers: {
+      "content-type": "application/json",
+      "X-Jishushell-Internal-Token": internalToken,
+      "X-Jishushell-Instance": INSTANCE_ID,
+    },
+    body: body === undefined ? undefined : JSON.stringify(body),
+  });
+  const text = await response.text();
+  let parsed;
+  try { parsed = text ? JSON.parse(text) : null; } catch (_) { parsed = { error:text }; }
+  if (!response.ok) {
+    throw new Error(parsed && (parsed.error || parsed.detail) || ("Core request failed: HTTP " + response.status));
+  }
+  return parsed;
+}
+
+function jsonText(value) { return JSON.stringify(value, null, 2); }
+function clampInt(value, fallback, min, max) {
+  const n = Number(value);
+  if (!Number.isFinite(n)) return fallback;
+  return Math.max(min, Math.min(max, Math.floor(n)));
+}
+function compactAsset(a) {
+  const exif = a && typeof a.exifInfo === "object" ? a.exifInfo : {};
+  return {
+    id: String(a && a.id || ""),
+    type: a && a.type,
+    originalFileName: a && a.originalFileName,
+    fileCreatedAt: a && a.fileCreatedAt,
+    fileModifiedAt: a && a.fileModifiedAt,
+    isFavorite: a && a.isFavorite,
+    isArchived: a && a.isArchived,
+    isTrashed: a && a.isTrashed,
+    score: a && typeof a.score === "number" ? a.score : a && typeof a.similarity === "number" ? a.similarity : undefined,
+    exifInfo: {
+      city: exif.city,
+      state: exif.state,
+      country: exif.country,
+      make: exif.make,
+      model: exif.model,
+      latitude: exif.latitude,
+      longitude: exif.longitude,
+      dateTimeOriginal: exif.dateTimeOriginal,
+    },
+  };
+}
+function assetList(payload) {
+  const root = payload && typeof payload === "object" ? payload : {};
+  const node = root.assets && typeof root.assets === "object" ? root.assets : root;
+  const items = Array.isArray(node.items) ? node.items : Array.isArray(root.items) ? root.items : Array.isArray(payload) ? payload : [];
+  return { items: items.map(compactAsset), total: node.total, page: node.page, size: node.size, nextPage: node.nextPage || null };
+}
+function compactAlbum(album, includeAssets) {
+  return {
+    id: String(album && album.id || ""),
+    albumName: String(album && album.albumName || ""),
+    description: album && album.description,
+    assetCount: album && album.assetCount,
+    createdAt: album && album.createdAt,
+    updatedAt: album && album.updatedAt,
+    ...(includeAssets ? { assets: (Array.isArray(album && album.assets) ? album.assets : []).map(compactAsset) } : {}),
+  };
+}
+function compactTag(tag) {
+  return { id: String(tag && tag.id || ""), name: String(tag && (tag.name || tag.value) || ""), color: tag && tag.color, value: tag && tag.value };
+}
+function compactPerson(person) {
+  return { id: String(person && person.id || ""), name: person && person.name, birthDate: person && person.birthDate, isHidden: person && person.isHidden, assetCount: person && person.assetCount };
+}
+function searchBody(args) {
+  const a = args || {};
+  const body = { page: clampInt(a.page, 1, 1, 10000), size: clampInt(a.size, 50, 1, 100) };
+  const stringFields = [["city","city"],["state","state"],["country","country"],["make","make"],["model","model"],["type","asset_type"],["takenAfter","taken_after"],["takenBefore","taken_before"],["fileCreatedAfter","file_created_after"],["fileCreatedBefore","file_created_before"]];
+  for (const [outKey, inKey] of stringFields) if (typeof a[inKey] === "string" && a[inKey].trim()) body[outKey] = a[inKey].trim();
+  const boolFields = [["isFavorite","is_favorite"],["isArchived","is_archived"],["isTrashed","is_trashed"]];
+  for (const [outKey, inKey] of boolFields) if (typeof a[inKey] === "boolean") body[outKey] = a[inKey];
+  if (Array.isArray(a.tag_ids)) body.tagIds = a.tag_ids.filter((v) => typeof v === "string" && v.trim());
+  return body;
+}
+function smartSearchBody(args) {
+  const a = args || {};
+  const body = { page: clampInt(a.page, 1, 1, 10000), size: clampInt(a.size, 50, 1, 100) };
+  const stringFields = [["query","query"],["queryAssetId","query_asset_id"],["city","city"],["state","state"],["country","country"],["takenAfter","taken_after"],["takenBefore","taken_before"]];
+  for (const [outKey, inKey] of stringFields) if (typeof a[inKey] === "string" && a[inKey].trim()) body[outKey] = a[inKey].trim();
+  if (Array.isArray(a.person_ids)) body.personIds = a.person_ids.filter((v) => typeof v === "string" && v.trim());
+  if (!body.query && !body.queryAssetId) throw new Error("search_smart requires query or query_asset_id");
+  return body;
+}
+async function immich(method, apiPath, opts) {
+  envCheck();
+  const apiKey = loadApiKey();
+  const url = new URL("/api" + apiPath, BASE_URL + "/");
+  for (const [key, value] of Object.entries((opts && opts.params) || {})) {
+    if (value !== undefined) url.searchParams.set(key, String(value));
+  }
+  const headers = { accept: (opts && opts.accept) || "application/json", "x-api-key": apiKey };
+  const init = { method, headers };
+  if (opts && Object.prototype.hasOwnProperty.call(opts, "body")) {
+    headers["content-type"] = "application/json";
+    init.body = JSON.stringify(opts.body);
+  }
+  const ctrl = new AbortController();
+  const t = setTimeout(() => ctrl.abort(), 30000);
+  init.signal = ctrl.signal;
+  try {
+    const res = await fetch(url.toString(), init);
+    if (!res.ok) {
+      const text = (await res.text()).slice(0, 400).split(apiKey).join("[redacted]");
+      throw new Error("Immich " + method + " " + apiPath + " failed: HTTP " + res.status + (text ? ": " + text : ""));
+    }
+    if ((opts && opts.raw) || res.status === 204) return res;
+    const text = await res.text();
+    return text.trim() ? JSON.parse(text) : null;
+  } finally {
+    clearTimeout(t);
+  }
+}
+
+function compactLibrary(library) {
+  return {
+    id: String(library && library.id || ""),
+    name: String(library && library.name || ""),
+    ownerId: String(library && library.ownerId || ""),
+    importPaths: Array.isArray(library && library.importPaths) ? library.importPaths.map(String) : [],
+    exclusionPatterns: Array.isArray(library && library.exclusionPatterns) ? library.exclusionPatterns.map(String) : [],
+    assetCount: Number(library && library.assetCount || 0),
+    refreshedAt: library && library.refreshedAt || null,
+    createdAt: library && library.createdAt,
+    updatedAt: library && library.updatedAt,
+  };
+}
+async function listPhotoLibraries() {
+  const libraries = await immich("GET", "/libraries");
+  return (Array.isArray(libraries) ? libraries : []).map(compactLibrary);
+}
+function selectPhotoLibrary(libraries) {
+  const byPath = libraries.filter((library) => library.importPaths.includes(PHOTO_LIBRARY_PATH));
+  if (byPath.length > 1) {
+    throw new Error("multiple Immich external libraries use " + PHOTO_LIBRARY_PATH + "; resolve the conflict in Immich");
+  }
+  return byPath[0] || null;
+}
+function unavailablePhotoLibraryStatus() {
+  return {
+    available: false,
+    configured: false,
+    reason: "default photo library is available only for JishuShell-managed Immich",
+    import_path: PHOTO_LIBRARY_PATH,
+  };
+}
+async function getPhotoLibraryStatus() {
+  if (!PHOTO_LIBRARY_ENABLED) return unavailablePhotoLibraryStatus();
+  const library = selectPhotoLibrary(await listPhotoLibraries());
+  if (!library) {
+    return {
+      available: true,
+      configured: false,
+      status: "not_initialized",
+      name: PHOTO_LIBRARY_NAME,
+      import_path: PHOTO_LIBRARY_PATH,
+    };
+  }
+  const statistics = await immich("GET", "/libraries/" + encodeURIComponent(library.id) + "/statistics");
+  return {
+    available: true,
+    configured: true,
+    status: library.refreshedAt ? "ready" : "not_scanned",
+    import_path: PHOTO_LIBRARY_PATH,
+    library,
+    statistics,
+  };
+}
+async function ensurePhotoLibrary() {
+  if (!PHOTO_LIBRARY_ENABLED) {
+    throw new Error("default photo library scanning is available only for JishuShell-managed Immich");
+  }
+  const libraries = await listPhotoLibraries();
+  const existing = selectPhotoLibrary(libraries);
+  if (existing) return existing;
+
+  const byName = libraries.filter((library) => library.name === PHOTO_LIBRARY_NAME);
+  if (byName.length > 1) {
+    throw new Error("multiple Immich external libraries are named " + PHOTO_LIBRARY_NAME + "; resolve the conflict in Immich");
+  }
+  if (byName.length === 1) {
+    const library = byName[0];
+    return compactLibrary(await immich("PUT", "/libraries/" + encodeURIComponent(library.id), {
+      body: {
+        name: library.name,
+        importPaths: uniqueStrings(library.importPaths.concat([PHOTO_LIBRARY_PATH])),
+        exclusionPatterns: library.exclusionPatterns,
+      },
+    }));
+  }
+
+  const user = await immich("GET", "/users/me");
+  if (!user || typeof user.id !== "string" || !user.id) {
+    throw new Error("Immich did not return the current user id");
+  }
+  if (user.isAdmin !== true) {
+    throw new Error("an Immich administrator API key is required to create the default photo library");
+  }
+  return compactLibrary(await immich("POST", "/libraries", {
+    body: {
+      ownerId: user.id,
+      name: PHOTO_LIBRARY_NAME,
+      importPaths: [PHOTO_LIBRARY_PATH],
+      exclusionPatterns: [],
+    },
+  }));
+}
+async function scanPhotoLibrary() {
+  const library = await ensurePhotoLibrary();
+  await immich("POST", "/libraries/" + encodeURIComponent(library.id) + "/scan");
+  return {
+    queued: true,
+    status: "scan_queued",
+    library_id: library.id,
+    library_name: library.name,
+    import_path: PHOTO_LIBRARY_PATH,
+    message: "Immich accepted the scan request. New photos are imported in the background.",
+  };
+}
+async function createPhotoUploadSession(args) {
+  if (!PHOTO_LIBRARY_ENABLED) {
+    throw new Error("photo upload links are available only for JishuShell-managed Immich");
+  }
+  return await coreSend("POST", "/api/integrations/immich/photo-upload-sessions", {
+    folderName: typeof args.folder_name === "string" ? args.folder_name : undefined,
+  });
+}
+
+function uniqueStrings(values) { return [...new Set((Array.isArray(values) ? values : []).filter((v) => typeof v === "string" && v.trim()))]; }
+async function generateReviewGallery(args) {
+  return await coreSend("POST", "/api/integrations/immich/reviews", args || {});
+}
+
+const TOOLS = [
+  { name:"ping", description:"Check Immich connectivity.", inputSchema:{type:"object",properties:{}} },
+  { name:"get_library_summary", description:"Return Immich version, statistics, and connection status.", inputSchema:{type:"object",properties:{}} },
+  { name:"get_photo_library_status", description:"Read the AI Box default external photo library status and statistics.", inputSchema:{type:"object",properties:{}} },
+  { name:"scan_photo_library", description:"Ensure the AI Box default external photo library exists and queue an Immich scan.", inputSchema:{type:"object",properties:{}} },
+  { name:"create_photo_upload_session", description:"Create a short-lived AI Box web page where the user can choose photos, videos, or a folder and upload directly over the local network. The same page can finish and scan multiple upload batches until it expires.", inputSchema:{type:"object",properties:{folder_name:{type:"string",description:"Optional human-readable name for uploaded batches."}}} },
+  { name:"get_asset_info", description:"Read compact metadata for one asset by id.", inputSchema:{type:"object",properties:{asset_id:{type:"string"}},required:["asset_id"]} },
+  { name:"list_assets", description:"List a bounded page of assets. Defaults to page=1,size=50; when no filters are provided, archived assets are excluded.", inputSchema:{type:"object",properties:{page:{type:"number",description:"Page number, default 1."},size:{type:"number",description:"Page size, default 50, maximum 100."},is_favorite:{type:"boolean"},is_archived:{type:"boolean"},is_trashed:{type:"boolean"},asset_type:{type:"string"}}} },
+  { name:"search_metadata", description:"Search a bounded page of assets by exact/structured metadata filters; this is not visual Smart Search / CLIP. Defaults to page=1,size=50.", inputSchema:{type:"object",properties:{city:{type:"string"},state:{type:"string"},country:{type:"string"},make:{type:"string"},model:{type:"string"},taken_after:{type:"string",description:"ISO date/time lower bound for the asset taken time."},taken_before:{type:"string",description:"ISO date/time upper bound for the asset taken time."},file_created_after:{type:"string",description:"ISO date/time lower bound for file creation time."},file_created_before:{type:"string",description:"ISO date/time upper bound for file creation time."},asset_type:{type:"string"},is_favorite:{type:"boolean"},is_archived:{type:"boolean"},is_trashed:{type:"boolean"},tag_ids:{type:"array",items:{type:"string"},description:"Optional Immich tag ids to filter by."},page:{type:"number",description:"Page number, default 1."},size:{type:"number",description:"Page size, default 50, maximum 100."}}} },
+  { name:"search_smart", description:"Return a bounded, ranked candidate page from Immich Smart Search / CLIP using natural language or a query asset. Read-only. Results are semantic similarity candidates, not a guaranteed classifier result or exhaustive set of all matching assets. Defaults to page=1,size=50.", inputSchema:{type:"object",properties:{query:{type:"string",description:"Natural-language visual query, for example 'dog playing in grass'."},query_asset_id:{type:"string",description:"Optional asset id for similar-image search."},taken_after:{type:"string",description:"ISO date/time lower bound for the asset taken time."},taken_before:{type:"string",description:"ISO date/time upper bound for the asset taken time."},city:{type:"string"},state:{type:"string"},country:{type:"string"},person_ids:{type:"array",items:{type:"string"},description:"Optional Immich person ids to narrow results."},page:{type:"number",description:"Page number, default 1."},size:{type:"number",description:"Page size, default 50, maximum 100."}}} },
+  { name:"get_map_markers", description:"Read geotag map markers.", inputSchema:{type:"object",properties:{is_archived:{type:"boolean"},is_favorite:{type:"boolean"},file_created_after:{type:"string"},file_created_before:{type:"string"}}} },
+  { name:"list_albums", description:"List albums.", inputSchema:{type:"object",properties:{shared:{type:"boolean"}}} },
+  { name:"get_album", description:"Read album details and compact asset ids.", inputSchema:{type:"object",properties:{album_id:{type:"string"}},required:["album_id"]} },
+  { name:"create_album", description:"Create an album container.", inputSchema:{type:"object",properties:{name:{type:"string"},description:{type:"string"},asset_ids:{type:"array",items:{type:"string"}}},required:["name"]} },
+  { name:"update_album", description:"Update album name or description.", inputSchema:{type:"object",properties:{album_id:{type:"string"},name:{type:"string"},description:{type:"string"}},required:["album_id"]} },
+  { name:"delete_album", description:"Delete an album container after the user has explicitly confirmed in chat. Photos in the album are NOT deleted and remain in the library. This removes the album grouping and is not simply undoable.", inputSchema:{type:"object",properties:{album_id:{type:"string"}},required:["album_id"]} },
+  { name:"list_tags", description:"List tags.", inputSchema:{type:"object",properties:{}} },
+  { name:"get_tag", description:"Read one tag.", inputSchema:{type:"object",properties:{tag_id:{type:"string"}},required:["tag_id"]} },
+  { name:"create_tag", description:"Create a tag.", inputSchema:{type:"object",properties:{name:{type:"string"},color:{type:"string"}},required:["name"]} },
+  { name:"update_tag", description:"Update tag name or color.", inputSchema:{type:"object",properties:{tag_id:{type:"string"},name:{type:"string"},color:{type:"string"}},required:["tag_id"]} },
+  { name:"delete_tag", description:"Delete a tag after the user has explicitly confirmed in chat. Photos are NOT deleted, but the tag is removed from every associated asset. This is not simply undoable.", inputSchema:{type:"object",properties:{tag_id:{type:"string"}},required:["tag_id"]} },
+  { name:"generate_review_gallery", description:"Create a Core-owned Immich review interaction for user selection and confirmation. Use this for bulk album/tag/trash/duplicate actions whenever the user must choose or confirm candidate assets. Return urls.web to the user; Core executes after UI confirmation, and the model should not claim success unless it later reads an execution result.", inputSchema:{type:"object",properties:{action:{type:"string",enum:["add_assets_to_album","remove_assets_from_album","tag_assets","untag_assets","delete_assets_to_trash","resolve_duplicates"],description:"Bound action to execute after UI confirmation. Use exactly one enum value."},title:{type:"string",description:"Human-readable review title shown in the UI."},asset_ids:{type:"array",items:{type:"string"},description:"Candidate asset ids from list/search/album results. The user chooses or confirms a subset in the UI."},preselected_asset_ids:{type:"array",items:{type:"string"},description:"Recommended asset ids to select by default in the UI. Must be a subset of asset_ids or resolved candidates. Use only for high-confidence recommendations; do not preselect every Smart Search / CLIP candidate by default."},album_id:{type:"string",description:"Required for add_assets_to_album and remove_assets_from_album. Also usable as a candidate source when asset_ids are omitted."},tag_id:{type:"string",description:"Required for tag_assets and untag_assets."},duplicate_id:{type:"string",description:"Duplicate group id for resolve_duplicates. Also usable as a candidate source when asset_ids are omitted."}},required:["action"]} },
+  { name:"restore_assets", description:"Restore specific trashed assets by id.", inputSchema:{type:"object",properties:{asset_ids:{type:"array",items:{type:"string"}}},required:["asset_ids"]} },
+  { name:"get_duplicates", description:"Read Immich duplicate groups.", inputSchema:{type:"object",properties:{}} },
+  { name:"list_people", description:"List people recognized by Immich, read-only.", inputSchema:{type:"object",properties:{page:{type:"number"},size:{type:"number"},with_hidden:{type:"boolean"}}} },
+  { name:"search_people", description:"Search people by name, read-only.", inputSchema:{type:"object",properties:{name:{type:"string"},with_hidden:{type:"boolean"}},required:["name"]} },
+  { name:"get_person", description:"Read one person, read-only.", inputSchema:{type:"object",properties:{person_id:{type:"string"}},required:["person_id"]} },
+  { name:"get_asset_faces", description:"Read faces detected in one asset, read-only.", inputSchema:{type:"object",properties:{asset_id:{type:"string"}},required:["asset_id"]} },
+];
+
+function send(msg) { process.stdout.write(JSON.stringify(msg) + "\\n"); }
+function reply(id, result) { if (id !== undefined) send({ jsonrpc:"2.0", id, result }); }
+function replyError(id, code, message) { if (id !== undefined) send({ jsonrpc:"2.0", id, error:{ code, message } }); }
+async function handleCall(name, args) {
+  args = args || {};
+  if (name === "ping") return await immich("GET", "/server/ping");
+  if (name === "get_library_summary") {
+    const out = { connected:false, baseUrl:BASE_URL };
+    const results = await Promise.allSettled([immich("GET","/server/ping"), immich("GET","/server/version"), immich("GET","/server/statistics")]);
+    out.connected = results[0].status === "fulfilled";
+    out.ping = results[0].status === "fulfilled" ? results[0].value : { error: String(results[0].reason && results[0].reason.message || results[0].reason) };
+    out.version = results[1].status === "fulfilled" ? results[1].value : { error: String(results[1].reason && results[1].reason.message || results[1].reason) };
+    out.statistics = results[2].status === "fulfilled" ? results[2].value : { error: String(results[2].reason && results[2].reason.message || results[2].reason) };
+    return out;
+  }
+  if (name === "get_photo_library_status") return await getPhotoLibraryStatus();
+  if (name === "scan_photo_library") return await scanPhotoLibrary();
+  if (name === "create_photo_upload_session") return await createPhotoUploadSession(args);
+  if (name === "get_asset_info") return compactAsset(await immich("GET", "/assets/" + encodeURIComponent(args.asset_id)));
+  if (name === "list_assets") { const b = searchBody(args); if (Object.keys(b).length <= 2) b.isArchived = false; return assetList(await immich("POST", "/search/metadata", { body:b })); }
+  if (name === "search_metadata") return assetList(await immich("POST", "/search/metadata", { body:searchBody(args) }));
+  if (name === "search_smart") return assetList(await immich("POST", "/search/smart", { body:smartSearchBody(args) }));
+  if (name === "get_map_markers") return await immich("GET", "/map/markers", { params:{ isArchived: args.is_archived === undefined ? false : !!args.is_archived, isFavorite: args.is_favorite, fileCreatedAfter: args.file_created_after, fileCreatedBefore: args.file_created_before } });
+  if (name === "list_albums") return (await immich("GET", "/albums", { params:{ shared: args.shared } })).map((x) => compactAlbum(x, false));
+  if (name === "get_album") return compactAlbum(await immich("GET", "/albums/" + encodeURIComponent(args.album_id)), true);
+  if (name === "create_album") return compactAlbum(await immich("POST", "/albums", { body:{ albumName: args.name, description: args.description || "", assetIds: uniqueStrings(args.asset_ids) } }), true);
+  if (name === "update_album") { const body = {}; if (args.name) body.albumName = args.name; if (args.description !== undefined) body.description = args.description; return compactAlbum(await immich("PATCH", "/albums/" + encodeURIComponent(args.album_id), { body }), true); }
+  if (name === "delete_album") { const album = compactAlbum(await immich("GET", "/albums/" + encodeURIComponent(args.album_id)), false); await immich("DELETE", "/albums/" + encodeURIComponent(args.album_id)); return { deleted:true, album_id:album.id, album_name:album.albumName, asset_count:album.assetCount, note:"Album deleted. Photos were not deleted and remain in the Immich library." }; }
+  if (name === "list_tags") return (await immich("GET", "/tags")).map(compactTag);
+  if (name === "get_tag") return compactTag(await immich("GET", "/tags/" + encodeURIComponent(args.tag_id)));
+  if (name === "create_tag") { const body = { name: args.name }; if (args.color) body.color = args.color; return compactTag(await immich("POST", "/tags", { body })); }
+  if (name === "update_tag") { const body = {}; if (args.name) body.name = args.name; if (args.color) body.color = args.color; return compactTag(await immich("PUT", "/tags/" + encodeURIComponent(args.tag_id), { body })); }
+  if (name === "delete_tag") { const tag = compactTag(await immich("GET", "/tags/" + encodeURIComponent(args.tag_id))); await immich("DELETE", "/tags/" + encodeURIComponent(args.tag_id)); return { deleted:true, tag_id:tag.id, tag_name:tag.name, note:"Tag deleted. Photos were not deleted, but this tag was removed from associated assets." }; }
+  if (name === "generate_review_gallery") return await generateReviewGallery(args);
+  if (name === "restore_assets") { const ids = uniqueStrings(args.asset_ids); await immich("POST", "/trash/restore/assets", { body:{ ids } }); return { restored:ids.length }; }
+  if (name === "get_duplicates") return await immich("GET", "/duplicates");
+  if (name === "list_people") { const data = await immich("GET", "/people", { params:{ page:clampInt(args.page,1,1,10000), size:clampInt(args.size,50,1,100), withHidden:!!args.with_hidden } }); const people = Array.isArray(data.people) ? data.people : Array.isArray(data.items) ? data.items : Array.isArray(data) ? data : []; return { ...data, people: people.map(compactPerson) }; }
+  if (name === "search_people") return (await immich("GET", "/search/person", { params:{ name:args.name, withHidden:!!args.with_hidden } })).map(compactPerson);
+  if (name === "get_person") return compactPerson(await immich("GET", "/people/" + encodeURIComponent(args.person_id)));
+  if (name === "get_asset_faces") return await immich("GET", "/faces", { params:{ id:args.asset_id } });
+  throw new Error("unknown tool: " + name);
+}
+async function handle(req) {
+  const { id, method, params } = req || {};
+  try {
+    if (method === "initialize") reply(id, { protocolVersion:"2024-11-05", capabilities:{ tools:{} }, serverInfo:{ name:"jishushell-immich-shim", version:VERSION } });
+    else if (method === "notifications/initialized") {}
+    else if (method === "tools/list") reply(id, { tools: TOOLS });
+    else if (method === "tools/call") reply(id, { content:[{ type:"text", text:jsonText(await handleCall(params && params.name, params && params.arguments)) }] });
+    else if (method === "ping") reply(id, {});
+    else replyError(id, -32601, "method not found: " + method);
+  } catch (e) {
+    replyError(id, -32000, e && e.message ? e.message : String(e));
+  }
+}
+const keepAlive = setInterval(() => {}, 2147483647);
+function shutdown(code) {
+  clearInterval(keepAlive);
+  process.exit(code);
+}
+
+const rl = readline.createInterface({ input: process.stdin, crlfDelay: Infinity, terminal: false });
+rl.on("line", (line) => {
+  const text = String(line || "").trim();
+  if (!text) return;
+  try { void handle(JSON.parse(text)); } catch (_) {}
+});
+rl.on("close", () => shutdown(0));
+process.on("SIGTERM", () => shutdown(0));
+process.on("SIGINT", () => shutdown(0));
+`;
+export function substituteImmichShimPlaceholders(input) {
+    return IMMICH_MCP_SHIM_SOURCE
+        .replaceAll("__JS_IMMICH_BASE_URL__", jsonLiteralContent(input.baseUrl.replace(/\/+$/, "")))
+        .replaceAll("__JS_IMMICH_PHOTO_LIBRARY_ENABLED__", input.photoLibraryEnabled === true ? "true" : "false")
+        .replaceAll("__JS_CORE_URL__", jsonLiteralContent(input.coreUrl?.replace(/\/+$/, "") ?? ""))
+        .replaceAll("__JS_INSTANCE_ID__", jsonLiteralContent(input.instanceId ?? ""));
+}
+function jsonLiteralContent(value) {
+    return JSON.stringify(value).slice(1, -1);
+}
+//# sourceMappingURL=immich-shim.js.map

package/dist/services/integrations/immich/immich-shim.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"immich-shim.js","sourceRoot":"","sources":["../../../../src/services/integrations/immich/immich-shim.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,iCAAiC,EACjC,iCAAiC,GAClC,MAAM,oBAAoB,CAAC;AAE5B,MAAM,CAAC,MAAM,uBAAuB,GAAG,OAAO,CAAC;AAC/C,MAAM,CAAC,MAAM,2BAA2B,GAAG,aAAa,CAAC;AACzD,OAAO,EACL,iCAAiC,EACjC,iCAAiC,GAClC,MAAM,oBAAoB,CAAC;AAE5B,MAAM,CAAC,MAAM,4BAA4B,GAAG;IAC1C,MAAM;IACN,qBAAqB;IACrB,0BAA0B;IAC1B,oBAAoB;IACpB,6BAA6B;IAC7B,gBAAgB;IAChB,aAAa;IACb,iBAAiB;IACjB,cAAc;IACd,iBAAiB;IACjB,aAAa;IACb,WAAW;IACX,cAAc;IACd,cAAc;IACd,cAAc;IACd,WAAW;IACX,SAAS;IACT,YAAY;IACZ,YAAY;IACZ,YAAY;IACZ,yBAAyB;IACzB,gBAAgB;IAChB,gBAAgB;IAChB,aAAa;IACb,eAAe;IACf,YAAY;IACZ,iBAAiB;CACT,CAAC;AAEX,MAAM,CAAC,MAAM,sBAAsB,GAAG;;;;;;;;kBAQpB,IAAI,CAAC,SAAS,CAAC,uBAAuB,CAAC;0BAC/B,IAAI,CAAC,SAAS,CAAC,2BAA2B,CAAC;;;;;6BAKxC,IAAI,CAAC,SAAS,CAAC,iCAAiC,CAAC;6BACjD,IAAI,CAAC,SAAS,CAAC,iCAAiC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2X7E,CAAC;AAEF,MAAM,UAAU,gCAAgC,CAAC,KAKhD;IACC,OAAO,sBAAsB;SAC1B,UAAU,CAAC,wBAAwB,EAAE,kBAAkB,CAAC,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC,CAAC;SAC3F,UAAU,CAAC,qCAAqC,EAAE,KAAK,CAAC,mBAAmB,KAAK,IAAI,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,OAAO,CAAC;SACxG,UAAU,CAAC,iBAAiB,EAAE,kBAAkB,CAAC,KAAK,CAAC,OAAO,EAAE,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC,IAAI,EAAE,CAAC,CAAC;SAC3F,UAAU,CAAC,oBAAoB,EAAE,kBAAkB,CAAC,KAAK,CAAC,UAAU,IAAI,EAAE,CAAC,CAAC,CAAC;AAClF,CAAC;AAED,SAAS,kBAAkB,CAAC,KAAa;IACvC,OAAO,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;AAC5C,CAAC"}

package/dist/services/integrations/immich/integration.d.ts

@@ -0,0 +1,18 @@
+import type { FastifyInstance } from "fastify";
+import type { AppIntegration, AppIntegrationManifest, CapabilityProfile, ConfigDocument, InstanceConfigMeta, PairingApproveInput, RuntimeSpec, RuntimeVersionInfo } from "../types.js";
+declare class ImmichIntegration implements AppIntegration {
+    readonly kind: "immich";
+    readonly displayName = "Immich";
+    readonly defaultCapabilities: CapabilityProfile;
+    readonly manifest: AppIntegrationManifest;
+    buildRuntime(_instanceId: string): Promise<RuntimeSpec>;
+    getRuntimeVersion(_instanceId: string): Promise<RuntimeVersionInfo>;
+    getConfigMeta(_instanceId: string): Promise<InstanceConfigMeta>;
+    readConfig(_instanceId: string): Promise<ConfigDocument>;
+    writeConfig(_instanceId: string, _doc: ConfigDocument): Promise<ConfigDocument>;
+    buildPairingListCommand(_instanceId: string): Promise<string[]>;
+    buildPairingApproveCommand(_instanceId: string, _input: PairingApproveInput): Promise<string[]>;
+    registerRoutes(app: FastifyInstance): Promise<void>;
+}
+export declare const immichIntegration: ImmichIntegration;
+export {};

package/dist/services/integrations/immich/integration.js

@@ -0,0 +1,64 @@
+import { registerIntegration } from "../registry.js";
+import { publicImmichConfigSummary, resolveImmichConfig } from "./config.js";
+const DEFAULT_CAPABILITIES = {
+    ui: { http: true, websocket: false, chatPanel: "none" },
+    pairing: { list: false, approve: false, revoke: false, clearPending: false },
+    configEditor: "custom",
+    configSchema: false,
+    customProvider: false,
+    pluginInstall: false,
+    skills: true,
+    mcp: true,
+    memory: false,
+    backupRestore: false,
+    usageStats: false,
+    restartlessReload: false,
+    messagingPlatforms: [],
+};
+class ImmichIntegration {
+    kind = "immich";
+    displayName = "Immich";
+    defaultCapabilities = DEFAULT_CAPABILITIES;
+    manifest = {
+        kind: "immich",
+        displayName: "Immich",
+        description: "Immich photo library exposed to agents through reviewed MCP tools",
+        defaultCapabilities: DEFAULT_CAPABILITIES,
+        catalogGroup: "apps",
+        catalogIcon: "gallery",
+        supportsClone: false,
+        connectionRole: "tool",
+        embeddedUiSurface: "none",
+    };
+    async buildRuntime(_instanceId) {
+        throw new Error("Immich MCP integration does not build or own the Immich runtime");
+    }
+    async getRuntimeVersion(_instanceId) {
+        return { integrationKind: "immich", ref: "external", mode: "baseline" };
+    }
+    async getConfigMeta(_instanceId) {
+        throw new Error("Immich MCP endpoint config is not exposed through the generic config editor");
+    }
+    async readConfig(_instanceId) {
+        return {
+            format: "json",
+            content: publicImmichConfigSummary(await resolveImmichConfig()),
+        };
+    }
+    async writeConfig(_instanceId, _doc) {
+        throw new Error("Immich V0 config writes are not available through this endpoint yet");
+    }
+    async buildPairingListCommand(_instanceId) {
+        return [];
+    }
+    async buildPairingApproveCommand(_instanceId, _input) {
+        return [];
+    }
+    async registerRoutes(app) {
+        const { registerImmichRoutes } = await import("./routes.js");
+        registerImmichRoutes(app);
+    }
+}
+export const immichIntegration = new ImmichIntegration();
+registerIntegration(immichIntegration);
+//# sourceMappingURL=integration.js.map

package/dist/services/integrations/immich/integration.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"integration.js","sourceRoot":"","sources":["../../../../src/services/integrations/immich/integration.ts"],"names":[],"mappings":"AAYA,OAAO,EAAE,mBAAmB,EAAE,MAAM,gBAAgB,CAAC;AACrD,OAAO,EAAE,yBAAyB,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AAE7E,MAAM,oBAAoB,GAAsB;IAC9C,EAAE,EAAE,EAAE,IAAI,EAAE,IAAI,EAAE,SAAS,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,EAAE;IACvD,OAAO,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,YAAY,EAAE,KAAK,EAAE;IAC5E,YAAY,EAAE,QAAQ;IACtB,YAAY,EAAE,KAAK;IACnB,cAAc,EAAE,KAAK;IACrB,aAAa,EAAE,KAAK;IACpB,MAAM,EAAE,IAAI;IACZ,GAAG,EAAE,IAAI;IACT,MAAM,EAAE,KAAK;IACb,aAAa,EAAE,KAAK;IACpB,UAAU,EAAE,KAAK;IACjB,iBAAiB,EAAE,KAAK;IACxB,kBAAkB,EAAE,EAAE;CACvB,CAAC;AAEF,MAAM,iBAAiB;IACZ,IAAI,GAAG,QAAiB,CAAC;IACzB,WAAW,GAAG,QAAQ,CAAC;IACvB,mBAAmB,GAAG,oBAAoB,CAAC;IAC3C,QAAQ,GAA2B;QAC1C,IAAI,EAAE,QAAQ;QACd,WAAW,EAAE,QAAQ;QACrB,WAAW,EAAE,mEAAmE;QAChF,mBAAmB,EAAE,oBAAoB;QACzC,YAAY,EAAE,MAAM;QACpB,WAAW,EAAE,SAAS;QACtB,aAAa,EAAE,KAAK;QACpB,cAAc,EAAE,MAAM;QACtB,iBAAiB,EAAE,MAAM;KAC1B,CAAC;IAEF,KAAK,CAAC,YAAY,CAAC,WAAmB;QACpC,MAAM,IAAI,KAAK,CAAC,iEAAiE,CAAC,CAAC;IACrF,CAAC;IAED,KAAK,CAAC,iBAAiB,CAAC,WAAmB;QACzC,OAAO,EAAE,eAAe,EAAE,QAAQ,EAAE,GAAG,EAAE,UAAU,EAAE,IAAI,EAAE,UAAU,EAAE,CAAC;IAC1E,CAAC;IAED,KAAK,CAAC,aAAa,CAAC,WAAmB;QACrC,MAAM,IAAI,KAAK,CAAC,6EAA6E,CAAC,CAAC;IACjG,CAAC;IAED,KAAK,CAAC,UAAU,CAAC,WAAmB;QAClC,OAAO;YACL,MAAM,EAAE,MAAM;YACd,OAAO,EAAE,yBAAyB,CAAC,MAAM,mBAAmB,EAAE,CAAC;SAChE,CAAC;IACJ,CAAC;IAED,KAAK,CAAC,WAAW,CAAC,WAAmB,EAAE,IAAoB;QACzD,MAAM,IAAI,KAAK,CAAC,qEAAqE,CAAC,CAAC;IACzF,CAAC;IAED,KAAK,CAAC,uBAAuB,CAAC,WAAmB;QAC/C,OAAO,EAAE,CAAC;IACZ,CAAC;IAED,KAAK,CAAC,0BAA0B,CAAC,WAAmB,EAAE,MAA2B;QAC/E,OAAO,EAAE,CAAC;IACZ,CAAC;IAED,KAAK,CAAC,cAAc,CAAC,GAAoB;QACvC,MAAM,EAAE,oBAAoB,EAAE,GAAG,MAAM,MAAM,CAAC,aAAa,CAAC,CAAC;QAC7D,oBAAoB,CAAC,GAAG,CAAC,CAAC;IAC5B,CAAC;CACF;AAED,MAAM,CAAC,MAAM,iBAAiB,GAAG,IAAI,iBAAiB,EAAE,CAAC;AACzD,mBAAmB,CAAC,iBAAiB,CAAC,CAAC"}

package/dist/services/integrations/immich/photo-library.d.ts

@@ -0,0 +1,4 @@
+import { ImmichClient } from "./client.js";
+export declare const IMMICH_DEFAULT_PHOTO_LIBRARY_NAME = "AI Box Photos";
+export declare const IMMICH_DEFAULT_PHOTO_LIBRARY_PATH = "/external/photos";
+export declare function queueDefaultPhotoLibraryScan(client: ImmichClient): Promise<Record<string, unknown>>;

package/dist/services/integrations/immich/photo-library.js

@@ -0,0 +1,63 @@
+export const IMMICH_DEFAULT_PHOTO_LIBRARY_NAME = "AI Box Photos";
+export const IMMICH_DEFAULT_PHOTO_LIBRARY_PATH = "/external/photos";
+export async function queueDefaultPhotoLibraryScan(client) {
+    const library = await ensureDefaultPhotoLibrary(client);
+    await client.scanLibrary(library.id);
+    return {
+        queued: true,
+        status: "scan_queued",
+        library_id: library.id,
+        library_name: library.name,
+        import_path: IMMICH_DEFAULT_PHOTO_LIBRARY_PATH,
+        message: "Immich accepted the scan request. New photos are imported in the background.",
+    };
+}
+async function ensureDefaultPhotoLibrary(client) {
+    const libraries = (await client.listLibraries()).map(compactLibrary);
+    const byPath = libraries.find((library) => library.importPaths.includes(IMMICH_DEFAULT_PHOTO_LIBRARY_PATH));
+    if (byPath)
+        return byPath;
+    const byName = libraries.filter((library) => library.name === IMMICH_DEFAULT_PHOTO_LIBRARY_NAME);
+    if (byName.length > 1) {
+        throw new Error(`multiple Immich external libraries are named ${IMMICH_DEFAULT_PHOTO_LIBRARY_NAME}; resolve the conflict in Immich`);
+    }
+    if (byName.length === 1) {
+        const library = byName[0];
+        return compactLibrary(await client.updateLibrary({
+            libraryId: library.id,
+            name: library.name,
+            importPaths: uniqueStrings([
+                ...library.importPaths,
+                IMMICH_DEFAULT_PHOTO_LIBRARY_PATH,
+            ]),
+            exclusionPatterns: library.exclusionPatterns,
+        }));
+    }
+    const user = await client.getCurrentUser();
+    const ownerId = typeof user.id === "string" ? user.id : "";
+    if (!ownerId)
+        throw new Error("Immich did not return the current user id");
+    if (user.isAdmin !== true) {
+        throw new Error("an Immich administrator API key is required to create the default photo library");
+    }
+    return compactLibrary(await client.createLibrary({
+        ownerId,
+        name: IMMICH_DEFAULT_PHOTO_LIBRARY_NAME,
+        importPaths: [IMMICH_DEFAULT_PHOTO_LIBRARY_PATH],
+        exclusionPatterns: [],
+    }));
+}
+function compactLibrary(input) {
+    return {
+        id: typeof input.id === "string" ? input.id : "",
+        name: typeof input.name === "string" ? input.name : "",
+        importPaths: uniqueStrings(input.importPaths),
+        exclusionPatterns: uniqueStrings(input.exclusionPatterns),
+    };
+}
+function uniqueStrings(input) {
+    if (!Array.isArray(input))
+        return [];
+    return [...new Set(input.filter((value) => typeof value === "string" && value.trim().length > 0))];
+}
+//# sourceMappingURL=photo-library.js.map

package/dist/services/integrations/immich/photo-library.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"photo-library.js","sourceRoot":"","sources":["../../../../src/services/integrations/immich/photo-library.ts"],"names":[],"mappings":"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"}

package/dist/services/integrations/immich/review-executor.d.ts

@@ -0,0 +1,3 @@
+import { ImmichClient } from "./client.js";
+import type { ImmichReviewExecutionPlan } from "./types.js";
+export declare function executeImmichReview(client: ImmichClient, plan: ImmichReviewExecutionPlan): Promise<Record<string, unknown>>;