FM / balavpn.abdallabala.com

/home/techb158/balavpn.abdallabala.com/

/home/techb158/balavpn.abdallabala.com

Name	Size	Mode	Actions
.git/	-	0755	rm
.github/	-	0755	rm
.next/	-	0777	rm
.well-known/	-	0755	rm
blxsenk/	-	0755	rm
bsahcio/	-	0755	rm
cgi-bin/	-	0755	rm
deploy/	-	0777	rm
docs/	-	0777	rm
emnbsuk/	-	0755	rm
gqefxrw/	-	0755	rm
jmvybrk/	-	0755	rm
ne1uwzb/	-	0755	rm
node_modules/	-	0777	rm
ojyauew/	-	0755	rm
oyqfklp/	-	0755	rm
prisma/	-	0777	rm
public/	-	0777	rm
rxfwzbq/	-	0755	rm
saas-app/	-	0755	rm
scripts/	-	0777	rm
src/	-	0755	rm
tests/	-	0777	rm
trwaeuc/	-	0755	rm
xqcyzpj/	-	0755	rm
yirxnfc/	-	0755	rm
.dockerignore	164	0644	edit dl rm
.env	1808	0666	edit dl rm
.env-backup	249	0666	edit dl rm
.env.example	1962	0644	edit dl rm
.env.production	1473	0644	edit dl rm
.gitignore	74	0644	edit dl rm
.htaccess	281	0644	edit dl rm
deploy.log	7656	0644	edit dl rm
docker-compose.monitoring.yml	254	0644	edit dl rm
docker-compose.prod.yml	3400	0644	edit dl rm
docker-compose.supabase.yml	1043	0644	edit dl rm
docker-compose.yml	2295	0644	edit dl rm
Dockerfile	1310	0644	edit dl rm
jsconfig.json	95	0644	edit dl rm
local-server.err.log	0	0666	edit dl rm
local-server.js	49177	0644	edit dl rm
local-server.out.log	0	0666	edit dl rm
mock-oidc-provider.js	7016	0644	edit dl rm
next.config.mjs	219	0644	edit dl rm
package-lock.json	237656	0644	edit dl rm
package.json	2296	0644	edit dl rm
README.md	2150	0644	edit dl rm
saas-app.zip	223122322	0644	edit dl rm
truncate_demo.sql	1676	0644	edit dl rm
wp-cron-owhg.php	1659	0644	edit dl rm

Edit: /home/techb158/balavpn.abdallabala.com/local-server.js (49177B)

const PORT = Number(process.env.PORT || 8090);
const source = JSON.parse(fs.readFileSync(path.join(__dirname, "..", "data", "database.json"), "utf8"));
const tables = source.tables;

const sourceProject = tables.projects[0];
const state = {
  organizations: [{ id: "org-demo", name: "COSMIC Demo Organization", slug: "cosmic-demo", status: "TRIAL", planCode: "pilot", manualBilling: true, allowedDomains: ["cosmic.local"], dataRetentionDays: 365 }],
  workspaces: [{ id: "workspace-demo", organizationId: "org-demo", name: "AI Risk Governance", slug: "ai-risk-governance", type: "B2B_TEAM", status: "TRIAL" }],
  users: [
    { id: "user-owner", organizationId: "org-demo", email: process.env.COSMIC_BOOTSTRAP_EMAIL || "super-owner@cosmic.local", displayName: process.env.COSMIC_BOOTSTRAP_NAME || "COSMIC Platform Owner", role: "owner", permissions: ROLE_PERMISSIONS.owner, status: "ACTIVE" },
    { id: "user-viewer", organizationId: "org-demo", email: "viewer@cosmic.local", displayName: "Read-only Viewer", role: "viewer", permissions: ROLE_PERMISSIONS.viewer, status: "ACTIVE" }
  ],
  subscriptions: [{ id: "sub-demo", organizationId: "org-demo", source: "MANUAL", status: "TRIALING", planCode: "pilot", adminOverride: true, limits: { users: 10, projects: 5, reportsPerMonth: 100, integrations: 4, storageMb: 1024 } }],
  projects: [], gates: [], auditEvents: [], invitations: [], integrations: [], mappings: [], syncRuns: [], reportExports: []
};

async function handleApi(req, res, pathname) {
  const method = req.method; const parts = pathname.split("/").filter(Boolean); const url = new URL(req.url, `http://${req.headers.host || "localhost"}`);
  if (method === "GET" && pathname === "/api/health") return sendJson(res, 200, { service: "COSMIC AI-Risk SaaS Local", version: "0.2.0", status: "ok" });
  if (method === "GET" && pathname === "/api/ready") return sendJson(res, 200, { ok: true, mode: "dependency-free-local", database: "prototype-seed-memory", postgresContainer: "saas-app-postgres-1" });
  if (method === "GET" && pathname === "/api/dashboard") return sendJson(res, 200, legacyDashboardPayload());
  if (method === "GET" && pathname === "/api/access/me") return sendJson(res, 200, legacyAccessPayload());
  if (method === "GET" && parts[0] === "api" && parts[1] === "projects" && parts[3] === "integrations") return sendJson(res, 200, { integrations: legacyIntegrations() });
  if (method === "GET" && parts[0] === "api" && parts[1] === "projects" && parts[3] === "integration-mappings") return sendJson(res, 200, { mappings: state.mappings });
  if (method === "GET" && parts[0] === "api" && parts[1] === "projects" && parts[3] === "sync-runs") return sendJson(res, 200, { syncRuns: state.syncRuns });
  if (method === "GET" && parts[0] === "api" && parts[1] === "projects" && parts[3] === "gate" && parts[4] === "history") return sendJson(res, 200, { gates: state.gates.filter(g => g.projectId === "project-demo").map(legacyGate) });
  if (method === "GET" && parts[0] === "api" && parts[1] === "projects" && parts[3] === "audit") return sendJson(res, 200, { auditEvents: state.auditEvents.filter(a => !parts[2] || a.projectId === "project-demo" || a.projectId === parts[2]) });
  if (method === "PATCH" && parts[0] === "api" && parts[1] === "gate-criteria") { const b = await parseBody(req); for (const gate of state.gates) { const criterion = (gate.criteria || []).find((item, index) => (item.id || `${gate.id}-criterion-${index + 1}`) === parts[2]); if (criterion) { Object.assign(criterion, b); audit("gate.criterion.update", "GateCriterion", parts[2], gate.projectId, criterion); return sendJson(res, 200, { criterion: legacyCriterion(criterion, 0, gate.id) }); } } return sendJson(res, 404, { error: "Gate criterion not found" }); }
  if (method === "GET" && parts[0] === "api" && parts[1] === "oauth") return sendJson(res, 200, { authorizeUrl: "/api/health", provider: parts[2], mode: "local-demo" });
  if (method === "POST" && parts[0] === "api" && parts[1] === "integrations" && parts[3] === "live" && parts[4] === "test") return sendJson(res, 200, { dryRun: true, message: "Live connector test is disabled in local demo mode." });
  if (method === "POST" && parts[0] === "api" && parts[1] === "integrations" && parts[3] === "live" && parts[4] === "sync") return sendJson(res, 200, { dryRun: true, message: "Live connector sync is disabled in local demo mode." });
  if (method === "GET" && parts[0] === "api" && parts[1] === "projects" && parts[3] === "reports") { const payload = legacyDashboardPayload(); const type = parts[4] || "full.json"; if (type === "executive.html") return sendText(res, 200, `<html><body><h1>${payload.dashboard.project.name}</h1><p>Overall score: ${payload.dashboard.summary.overallScore}</p><p>Gate: ${payload.dashboard.summary.gateStatus}</p><p>Open risks: ${payload.dashboard.summary.openRisks}</p></body></html>`, "text/html; charset=utf-8"); if (type === "risk-register.csv") return sendText(res, 200, csv(payload.dashboard.scoredRisks, ["id","title","dimension","status","normalizedScore","residualScore"]), "text/csv; charset=utf-8"); if (type === "mitigations.csv") return sendText(res, 200, csv(payload.dashboard.mitigations, ["id","title","riskId","status","progress_percent","effectiveness_percent"]), "text/csv; charset=utf-8"); if (type === "gate") return sendJson(res, 200, { report: { gate: payload.dashboard.gate, gates: state.gates.map(legacyGate) } }); if (type === "audit") return sendJson(res, 200, { report: { auditEvents: state.auditEvents } }); return sendJson(res, 200, { reportType: type, data: payload.data, dashboard: payload.dashboard, report: payload }); }
  if (method === "GET" && pathname === "/api/local/state") return sendJson(res, 200, fullState());
  if (method === "GET" && pathname === "/api/auth/me") return sendJson(res, 200, { actor: { ...publicUser(state.users[0]), memberships: [{ organizationId: "org-demo", organizationName: state.organizations[0].name, role: "owner", permissions: ROLE_PERMISSIONS.owner, status: "ACTIVE" }] } });
  if (method === "POST" && pathname === "/api/auth/invite") { const b = await parseBody(req); const inv = { id: makeId("invite"), organizationId: b.organizationId || "org-demo", email: b.email, roleCode: b.roleCode || "viewer", token: makeId("token"), expiresAt: new Date(Date.now()+7*864e5).toISOString(), acceptedAt: null }; state.invitations.unshift(inv); audit("invite.create", "Invitation", inv.id, null, inv); return sendJson(res, 201, { invitation: inv }); }
  if (method === "POST" && pathname === "/api/auth/accept-invite") { const b = await parseBody(req); const inv = state.invitations.find(i => i.token === b.token); if (!inv) return sendJson(res, 400, { error: "Invitation is invalid or expired." }); const u = { id: makeId("user"), organizationId: inv.organizationId, email: inv.email, displayName: b.displayName || inv.email, role: inv.roleCode, permissions: ROLE_PERMISSIONS[inv.roleCode] || ROLE_PERMISSIONS.viewer, status: "ACTIVE" }; inv.acceptedAt = now(); state.users.push(u); audit("invite.accept", "User", u.id, null, publicUser(u)); return sendJson(res, 200, { user: publicUser(u), membership: { organizationId: inv.organizationId, status: "ACTIVE", role: inv.roleCode } }); }
  if (method === "GET" && pathname === "/api/organizations") return sendJson(res, 200, { organizations: state.organizations });
  if (method === "POST" && pathname === "/api/organizations") { const b = await parseBody(req); const org = { id: makeId("org"), name: b.name, slug: b.slug || slug(b.name), status: "TRIAL", planCode: b.planCode || "pilot", manualBilling: true, allowedDomains: [], dataRetentionDays: 365 }; state.organizations.push(org); audit("organization.create", "Organization", org.id, null, org); return sendJson(res, 201, { organization: org }); }
  if (method === "GET" && pathname === "/api/workspaces") return sendJson(res, 200, { workspaces: state.workspaces.filter(w => !url.searchParams.get("organizationId") || w.organizationId === url.searchParams.get("organizationId")) });
  if (method === "POST" && pathname === "/api/workspaces") { const b = await parseBody(req); const ws = { id: makeId("workspace"), organizationId: b.organizationId || "org-demo", name: b.name, slug: b.slug || slug(b.name), type: b.type || "B2B_TEAM", status: "TRIAL" }; state.workspaces.push(ws); audit("workspace.create", "Workspace", ws.id, null, ws); return sendJson(res, 201, { workspace: ws }); }
  if (method === "PATCH" && parts[0] === "api" && parts[1] === "workspaces" && parts.length === 3) { const ws = state.workspaces.find(w => w.id === parts[2]); if (!ws) return sendJson(res, 404, { error: "Workspace not found" }); Object.assign(ws, await parseBody(req)); audit("workspace.update", "Workspace", ws.id, null, ws); return sendJson(res, 200, { workspace: ws }); }
  if (method === "GET" && pathname === "/api/users") return sendJson(res, 200, { users: state.users.map(publicUser) });
  if (method === "GET" && pathname === "/api/roles") return sendJson(res, 200, { roles: Object.entries(ROLE_PERMISSIONS).map(([code, permissions]) => ({ code, permissions })) });
  if (method === "GET" && parts[0] === "api" && parts[1] === "workspaces" && parts[3] === "projects") return sendJson(res, 200, { projects: state.projects.filter(p => p.workspaceId === parts[2]) });
  if (method === "POST" && parts[0] === "api" && parts[1] === "workspaces" && parts[3] === "projects") { const b = await parseBody(req); const p = { id: makeId("project"), workspaceId: parts[2], name: b.name, subtitle: b.subtitle || "COSMIC AI risk workspace", projectType: b.projectType || "AI-Enabler", currentLifecyclePhase: b.currentLifecyclePhase || "Needs identification", riskAppetite: Number(b.riskAppetite || 50), assessmentDate: now().slice(0,10), status: "Active", ownerDisplayName: "COSMIC Platform Owner", description: b.description || "", thresholds: b.thresholds || {}, reviews: b.reviews || {}, lifecyclePhases: [], risks: [], indicators: [], experiments: [] }; state.projects.push(p); audit("project.create", "Project", p.id, p.id, p); return sendJson(res, 201, { project: p }); }
  if (method === "GET" && parts[0] === "api" && parts[1] === "projects" && parts[3] === "dashboard") { const d = getDashboard(parts[2]); return d ? sendJson(res, 200, { dashboard: d }) : sendJson(res, 404, { error: "Project not found" }); }
  if (method === "GET" && parts[0] === "api" && parts[1] === "projects" && parts[3] === "risks") { const d = getDashboard(parts[2]); return d ? sendJson(res, 200, { risks: d.scoredRisks }) : sendJson(res, 404, { error: "Project not found" }); }
  if (method === "POST" && parts[0] === "api" && parts[1] === "projects" && parts[3] === "risks") { const b = await parseBody(req); const p = getProject(parts[2]); if (!p) return sendJson(res, 404, { error: "Project not found" }); const r = { id: makeId("risk"), projectId: p.id, ownerDisplayName: b.ownerDisplayName || "COSMIC Platform Owner", title: b.title, description: b.description || "", dimension: b.dimension || "Technical", domain: b.domain || "Technical risks", lifecyclePhase: b.lifecyclePhase || p.currentLifecyclePhase || "Needs identification", probability: Number(b.probability || 3), impact: Number(b.impact || 3), detectability: Number(b.detectability || 3), status: riskStatus(b.status), approvalStatus: approvalStatus(b.approvalStatus), dueDate: b.dueDate || null, evidenceSummary: b.evidenceSummary || "", mitigations: [], evidence: [] }; p.risks.push(r); audit("risk.create", "Risk", r.id, p.id, r); return sendJson(res, 201, { risk: scoreRisk(r) }); }
  if ((method === "PATCH" || method === "DELETE") && parts[0] === "api" && parts[1] === "risks" && parts.length === 3) { const found = getRisk(parts[2]); if (!found.risk) return sendJson(res, 404, { error: "Risk not found" }); if (method === "DELETE") { found.project.risks = found.project.risks.filter(r => r.id !== parts[2]); audit("risk.delete", "Risk", parts[2], found.project.id); return sendJson(res, 200, { deleted: true }); } const b = await parseBody(req); Object.assign(found.risk, b, { status: b.status ? riskStatus(b.status) : found.risk.status, approvalStatus: b.approvalStatus ? approvalStatus(b.approvalStatus) : found.risk.approvalStatus }); audit("risk.update", "Risk", found.risk.id, found.project.id, found.risk); return sendJson(res, 200, { risk: scoreRisk(found.risk) }); }
  if (method === "GET" && parts[0] === "api" && parts[1] === "projects" && parts[3] === "mitigations") return sendJson(res, 200, { mitigations: getAllMitigations(parts[2]) });
  if (method === "POST" && parts[0] === "api" && parts[1] === "risks" && parts[3] === "mitigations") { const b = await parseBody(req); const found = getRisk(parts[2]); if (!found.risk) return sendJson(res, 404, { error: "Risk not found" }); const m = { id: makeId("mit"), riskId: found.risk.id, ownerDisplayName: b.ownerDisplayName || "COSMIC Platform Owner", title: b.title, description: b.description || "", status: mitigationStatus(b.status), progressPercent: Number(b.progressPercent || b.progress_percent || 0), effectivenessPercent: Number(b.effectivenessPercent || b.effectiveness_percent || 0), dueDate: b.dueDate || null, sequence: found.risk.mitigations.length + 1, evidence: [] }; found.risk.mitigations.push(m); if (b.evidenceTitle || b.evidenceUri) m.evidence.push({ id: makeId("evd"), title: b.evidenceTitle || b.evidenceUri, uri: b.evidenceUri || null, type: b.evidenceType || "Review" }); audit("mitigation.create", "Mitigation", m.id, found.project.id, m); return sendJson(res, 201, { mitigation: m }); }
  if ((method === "PATCH" || method === "DELETE") && parts[0] === "api" && parts[1] === "mitigations" && parts.length === 3) { const found = getMitigation(parts[2]); if (!found.mitigation) return sendJson(res, 404, { error: "Mitigation not found" }); if (method === "DELETE") { found.risk.mitigations = found.risk.mitigations.filter(m => m.id !== parts[2]); audit("mitigation.delete", "Mitigation", parts[2], found.project.id); return sendJson(res, 200, { deleted: true }); } const b = await parseBody(req); Object.assign(found.mitigation, b, { status: b.status ? mitigationStatus(b.status) : found.mitigation.status }); audit("mitigation.update", "Mitigation", found.mitigation.id, found.project.id, found.mitigation); return sendJson(res, 200, { mitigation: found.mitigation }); }
  if (method === "POST" && parts[0] === "api" && parts[1] === "mitigations" && parts[3] === "evidence") { const b = await parseBody(req); const found = getMitigation(parts[2]); if (!found.mitigation) return sendJson(res, 404, { error: "Mitigation not found" }); const ev = { id: makeId("evd"), title: b.title || b.evidenceTitle || b.uri, uri: b.uri || b.evidenceUri || null, type: b.type || "Review" }; found.mitigation.evidence.push(ev); audit("evidence.create", "Evidence", ev.id, found.project.id, ev); return sendJson(res, 201, { evidence: ev }); }
  if (method === "GET" && parts[0] === "api" && parts[1] === "projects" && parts[3] === "gate" && parts[4] === "history") return sendJson(res, 200, { gates: state.gates.filter(g => g.projectId === parts[2]) });
  if (method === "POST" && parts[0] === "api" && parts[1] === "projects" && parts[3] === "gate" && parts[4] === "evaluate") { const d = getDashboard(parts[2]); if (!d) return sendJson(res, 404, { error: "Project not found" }); const g = { id: makeId("gate"), projectId: parts[2], status: d.gate.status, summary: d.gate.message, criteria: d.gate.criteria, decisions: [], evaluatedAt: now() }; state.gates.unshift(g); audit("gate.evaluate", "Gate", g.id, parts[2], g); return sendJson(res, 201, { gate: legacyGate(g), persistedGate: legacyGate(g) }); }
  if (method === "POST" && parts[0] === "api" && parts[1] === "gates" && parts[3] === "decisions") { const b = await parseBody(req); const g = state.gates.find(x => x.id === parts[2]); if (!g) return sendJson(res, 404, { error: "Gate not found" }); const d = { id: makeId("decision"), gateId: g.id, decision: b.decision || "NEEDS_CHANGES", reviewerName: b.reviewerName || "Governance Reviewer", reason: b.reason || "", decidedAt: now() }; g.decisions.push(d); audit("gate.decision", "GateDecision", d.id, g.projectId, d); return sendJson(res, 201, { decision: d }); }
  if (method === "GET" && parts[0] === "api" && parts[1] === "projects" && parts[3] === "audit") return sendJson(res, 200, { auditEvents: state.auditEvents.filter(a => a.projectId === parts[2]) });
  if (method === "GET" && parts[0] === "api" && parts[1] === "projects" && parts[3] === "reports") { const d = getDashboard(parts[2]); if (!d) return sendJson(res, 404, { error: "Project not found" }); const type = parts[4] || "full"; state.reportExports.unshift({ id: makeId("report"), projectId: parts[2], reportType: type, createdAt: now() }); if (type === "executive.html") return sendText(res, 200, `<html><body><h1>${d.project.name}</h1><p>Overall score: ${d.summary.overallScore}</p><p>Gate: ${d.summary.gateStatus}</p><p>Open risks: ${d.summary.openRisks}</p></body></html>`, "text/html; charset=utf-8"); if (type === "risk-register.csv") return sendText(res, 200, csv(d.scoredRisks, ["id","title","dimension","status","normalizedScore","residualScore"]), "text/csv; charset=utf-8"); return sendJson(res, 200, { reportType: type, dashboard: d, auditEvents: state.auditEvents.filter(a => a.projectId === parts[2]) }); }
  if (method === "GET" && pathname === "/api/integration-providers") return sendJson(res, 200, { providers: listSupportedProviders() });
  if (method === "GET" && parts[0] === "api" && parts[1] === "workspaces" && parts[3] === "integrations") return sendJson(res, 200, { integrations: state.integrations.filter(i => i.workspaceId === parts[2]) });
  if (method === "POST" && parts[0] === "api" && parts[1] === "integrations" && parts[3] === "sync") { const i = state.integrations.find(x => x.id === parts[2]); if (!i) return sendJson(res, 404, { error: "Integration not found" }); const p = state.projects.find(x => x.workspaceId === i.workspaceId); const d = getDashboard(p.id); let created = 0; d.scoredRisks.forEach(r => { if (!state.mappings.find(m => m.integrationId === i.id && m.localEntityId === r.id)) { created += 1; state.mappings.push({ id: makeId("map"), integrationId: i.id, projectId: p.id, provider: i.provider, localEntityType: "Risk", localEntityId: r.id, localTitle: r.title, externalItemType: "Work item", externalItemId: `${i.provider}-${r.id}`, externalStatus: riskStatusToExternalStatus(i.provider, r), syncStatus: "Synced", lastSyncedAt: now() }); } }); const run = { id: makeId("sync"), integrationId: i.id, projectId: p.id, provider: i.provider, status: "Completed", createdCount: created, updatedCount: d.scoredRisks.length - created, failedCount: 0, summary: `${i.provider} simulated sync completed.`, startedAt: now(), finishedAt: now() }; i.connectionStatus = "CONNECTED"; i.lastSyncAt = now(); state.syncRuns.unshift(run); audit("integration.sync", "IntegrationSyncRun", run.id, p.id, run); return sendJson(res, 200, { integration: i, syncRun: run, mappings: state.mappings.filter(m => m.integrationId === i.id) }); }
  if (method === "GET" && parts[0] === "api" && parts[1] === "workspaces" && parts[3] === "integration-mappings") return sendJson(res, 200, { mappings: state.mappings.filter(m => state.integrations.find(i => i.id === m.integrationId && i.workspaceId === parts[2])) });
  if (method === "GET" && parts[0] === "api" && parts[1] === "workspaces" && parts[3] === "sync-runs") return sendJson(res, 200, { syncRuns: state.syncRuns.filter(s => state.projects.find(p => p.id === s.projectId && p.workspaceId === parts[2])) });
  if (method === "GET" && pathname === "/api/billing/subscription") return sendJson(res, 200, { subscription: state.subscriptions[0], entitlements: { active: ["TRIALING","ACTIVE"].includes(state.subscriptions[0].status), limits: state.subscriptions[0].limits } });
  if (method === "PATCH" && pathname === "/api/billing/subscription") { Object.assign(state.subscriptions[0], await parseBody(req)); audit("billing.update", "Subscription", state.subscriptions[0].id, null, state.subscriptions[0]); return sendJson(res, 200, { subscription: state.subscriptions[0] }); }
  if (pathname === "/api/billing/checkout" || pathname === "/api/billing/portal" || pathname === "/api/billing/webhook") return sendJson(res, 200, { mode: "manual", message: "Stripe boundary placeholder active in local mode." });
  return sendJson(res, 404, { error: "API route not found", pathname });
}

cmd: