Local social media automation dashboard for TikTok, Instagram, and YouTube.
const fs = require("fs/promises");
const path = require("path");
const { config } = require("./config");
const STATE_FILE = path.resolve(config.projectRoot, "accounts-state.json");
const DEFAULT_ACCOUNT = { id: "default", name: "Default" };
const LEGACY_PROFILE_DIRS = {
tiktok: config.profileDir,
instagram: config.instagramProfileDir,
youtube: config.youtubeProfileDir,
};
let state = {
activeAccountId: DEFAULT_ACCOUNT.id,
accounts: [DEFAULT_ACCOUNT],
};
let loaded = false;
function clone(value) {
return JSON.parse(JSON.stringify(value));
}
function normalizeState(raw) {
const accounts = Array.isArray(raw?.accounts)
? raw.accounts
.filter((item) => item && typeof item.id === "string" && typeof item.name === "string")
.map((item) => ({ id: item.id, name: item.name }))
: [];
if (!accounts.length) {
accounts.push({ ...DEFAULT_ACCOUNT });
}
const activeExists = accounts.some((item) => item.id === raw?.activeAccountId);
const activeAccountId = activeExists ? raw.activeAccountId : accounts[0].id;
return { accounts, activeAccountId };
}
function sanitizeName(name) {
return (name || "").toString().trim().replace(/\s+/g, " ").slice(0, 60);
}
function makeId(name) {
const base = name
.toLowerCase()
.replace(/[^a-z0-9]+/g, "-")
.replace(/^-+|-+$/g, "")
.slice(0, 40);
return base || "account";
}
function ensureUniqueId(baseId, existing) {
if (!existing.has(baseId)) return baseId;
let index = 2;
while (existing.has(`${baseId}-${index}`)) {
index += 1;
}
return `${baseId}-${index}`;
}
async function saveState() {
await fs.writeFile(STATE_FILE, JSON.stringify(state, null, 2), "utf8");
}
async function ensureLoaded() {
if (loaded) return;
try {
const raw = await fs.readFile(STATE_FILE, "utf8");
state = normalizeState(JSON.parse(raw));
} catch {
state = normalizeState(state);
await saveState();
}
loaded = true;
}
async function getState() {
await ensureLoaded();
return clone(state);
}
// Queue directory helpers
const PLATFORMS = ["tiktok", "instagram", "youtube"];
const SUBDIRS = ["pending", "posted", "failed"];
function getAccountQueueDirs(accountId) {
const base = path.resolve(config.projectRoot, "queue", accountId);
const dirs = {};
for (const platform of PLATFORMS) {
dirs[platform] = {};
for (const sub of SUBDIRS) {
dirs[platform][sub] = path.resolve(base, platform, sub);
}
}
return dirs;
}
async function ensureAccountDirs(accountId) {
const dirs = getAccountQueueDirs(accountId);
const allPaths = [];
for (const platform of PLATFORMS) {
for (const sub of SUBDIRS) {
allPaths.push(dirs[platform][sub]);
}
}
// Also ensure browser profile dirs
const profileBase = path.resolve(config.projectRoot, ".profiles", accountId);
for (const platform of PLATFORMS) {
allPaths.push(path.resolve(profileBase, platform));
}
await Promise.all(allPaths.map((d) => fs.mkdir(d, { recursive: true })));
return dirs;
}
// Account CRUD
async function addAccount(name) {
await ensureLoaded();
const cleanName = sanitizeName(name);
if (!cleanName) {
throw new Error("Account name is required.");
}
const existingIds = new Set(state.accounts.map((item) => item.id));
const id = ensureUniqueId(makeId(cleanName), existingIds);
const account = { id, name: cleanName };
state.accounts.push(account);
state.activeAccountId = account.id;
await saveState();
// Create queue and profile directories for the new account
await ensureAccountDirs(id);
return clone(account);
}
async function selectAccount(accountId) {
await ensureLoaded();
const target = state.accounts.find((item) => item.id === accountId);
if (!target) {
throw new Error("Account not found.");
}
state.activeAccountId = target.id;
await saveState();
return clone(target);
}
async function getActiveAccount() {
await ensureLoaded();
return clone(
state.accounts.find((item) => item.id === state.activeAccountId) || state.accounts[0]
);
}
async function getAllAccounts() {
await ensureLoaded();
return clone(state.accounts);
}
async function getPlatformProfileDir(platform, accountId) {
const acctId = accountId || (await getActiveAccount()).id;
if (acctId === DEFAULT_ACCOUNT.id && LEGACY_PROFILE_DIRS[platform]) {
try {
await fs.stat(LEGACY_PROFILE_DIRS[platform]);
return LEGACY_PROFILE_DIRS[platform];
} catch {
// Fall through to new path
}
}
return path.resolve(config.projectRoot, ".profiles", acctId, platform);
}
async function hasSavedPlatformSession(platform, accountId) {
const profileDir = await getPlatformProfileDir(platform, accountId);
const cookieCandidates = [
path.resolve(profileDir, "Default", "Cookies"),
path.resolve(profileDir, "Cookies"),
path.resolve(profileDir, "Network", "Cookies"),
];
for (const filePath of cookieCandidates) {
try {
const stat = await fs.stat(filePath);
if (stat.isFile() && stat.size > 0) {
return true;
}
} catch {
// continue
}
}
return false;
}
module.exports = {
getState,
addAccount,
selectAccount,
getActiveAccount,
getAllAccounts,
getAccountQueueDirs,
ensureAccountDirs,
getPlatformProfileDir,
hasSavedPlatformSession,
PLATFORMS,
};